Showing preview only (9,855K chars total). Download the full file or copy to clipboard to get everything.
Repository: actonlang/acton
Branch: main
Commit: 8ac1f50c34d2
Files: 1091
Total size: 9.2 MB
Directory structure:
gitextract_p92zbpa_/
├── .containerignore
├── .github/
│ ├── ISSUE_TEMPLATE/
│ │ ├── blank_issue.md
│ │ ├── bug.yaml
│ │ ├── config.yml
│ │ ├── feature.yaml
│ │ └── ice.yaml
│ ├── dependabot.yml
│ └── workflows/
│ ├── claude.yml
│ ├── code-agent.yml
│ ├── create-release.yml
│ ├── release.yml
│ ├── test-app.yml
│ ├── test.yml
│ ├── trigger-web-update.yml
│ ├── update-ask-acton-vector-store.yml
│ └── webex-notifications.yml
├── .gitignore
├── .gitmodules
├── AGENTS.md
├── CHANGELOG.md
├── CLAUDE.md
├── CONTRIBUTING.md
├── Containerfile
├── Containerfile.deb
├── LICENSE
├── Makefile
├── README.md
├── backend/
│ ├── .gitignore
│ ├── Build.act
│ ├── CLAUDE.md
│ ├── actondb.c
│ ├── client_api.c
│ ├── client_api.h
│ ├── comm.c
│ ├── comm.h
│ ├── common.h
│ ├── consumer_state.h
│ ├── db.c
│ ├── db.h
│ ├── db_client_api.h
│ ├── failure_detector/
│ │ ├── cells.c
│ │ ├── cells.h
│ │ ├── db_messages.pb-c.c
│ │ ├── db_messages.pb-c.h
│ │ ├── db_messages.proto
│ │ ├── db_messages_test.c
│ │ ├── db_queries.c
│ │ ├── db_queries.h
│ │ ├── fd.c
│ │ ├── fd.h
│ │ ├── txns.h
│ │ ├── vector_clock.c
│ │ └── vector_clock.h
│ ├── fastrand.h
│ ├── hash_ring.c
│ ├── hash_ring.h
│ ├── hashes.h
│ ├── log.c
│ ├── log.h
│ ├── queue.c
│ ├── queue.h
│ ├── queue_callback.c
│ ├── queue_callback.h
│ ├── queue_groups.c
│ ├── queue_groups.h
│ ├── skiplist.c
│ ├── skiplist.h
│ ├── test/
│ │ ├── actor_ring_tests_local.c
│ │ ├── actor_ring_tests_remote.c
│ │ ├── db_unit_tests.c
│ │ ├── queue_unit_tests.c
│ │ ├── skiplist_test.c
│ │ └── test_client.c
│ ├── txn_state.c
│ ├── txn_state.h
│ ├── txns.c
│ └── txns.h
├── base/
│ ├── .gitignore
│ ├── Build.act
│ ├── CLAUDE.md
│ ├── __root.zig
│ ├── acton.zig
│ ├── builtin/
│ │ ├── Iterator.c
│ │ ├── Iterator.h
│ │ ├── atom.c
│ │ ├── atom.h
│ │ ├── bigint.c
│ │ ├── bigint.h
│ │ ├── bool.c
│ │ ├── bool.h
│ │ ├── box.c
│ │ ├── box.h
│ │ ├── builtin.c
│ │ ├── builtin.h
│ │ ├── builtin_functions.c
│ │ ├── builtin_functions.h
│ │ ├── class_hierarchy.c
│ │ ├── class_hierarchy.h
│ │ ├── common.c
│ │ ├── common.h
│ │ ├── complex.c
│ │ ├── complx.h
│ │ ├── csiphash.c
│ │ ├── dict.c
│ │ ├── dict.h
│ │ ├── env.c
│ │ ├── env.h
│ │ ├── exceptions.c
│ │ ├── exceptions.h
│ │ ├── float.c
│ │ ├── float.h
│ │ ├── function.c
│ │ ├── function.h
│ │ ├── hasher.c
│ │ ├── hasher.h
│ │ ├── i16.c
│ │ ├── i16.h
│ │ ├── i32.c
│ │ ├── i32.h
│ │ ├── i8.c
│ │ ├── i8.h
│ │ ├── int.c
│ │ ├── int.h
│ │ ├── list.c
│ │ ├── list.h
│ │ ├── none.c
│ │ ├── none.h
│ │ ├── range.c
│ │ ├── range.h
│ │ ├── registration.c
│ │ ├── registration.h
│ │ ├── serialize.c
│ │ ├── serialize.h
│ │ ├── set.c
│ │ ├── set.h
│ │ ├── slice.c
│ │ ├── slice.h
│ │ ├── staticWitnesses.c
│ │ ├── staticWitnesses.h
│ │ ├── str.c
│ │ ├── str.h
│ │ ├── timsort.c
│ │ ├── tuple.c
│ │ ├── tuple.h
│ │ ├── u1.c
│ │ ├── u1.h
│ │ ├── u16.c
│ │ ├── u16.h
│ │ ├── u32.c
│ │ ├── u32.h
│ │ ├── u64.c
│ │ ├── u64.h
│ │ ├── u8.c
│ │ ├── u8.h
│ │ ├── utils.c
│ │ └── utils.h
│ ├── rts/
│ │ ├── common.c
│ │ ├── common.h
│ │ ├── gc.zig
│ │ ├── io.c
│ │ ├── io.h
│ │ ├── log.c
│ │ ├── log.h
│ │ ├── netstring.c
│ │ ├── netstring.h
│ │ ├── q.c
│ │ ├── q.h
│ │ ├── rts.c
│ │ └── rts.h
│ └── src/
│ ├── __builtin__.act
│ ├── __builtin__.ext.c
│ ├── acton/
│ │ ├── rts.act
│ │ └── rts.ext.c
│ ├── argparse.act
│ ├── base64.act
│ ├── base64.ext.c
│ ├── buildy.act
│ ├── crypto/
│ │ └── hash/
│ │ ├── md5.act
│ │ └── md5.ext.c
│ ├── diff.act
│ ├── file.act
│ ├── file.ext.c
│ ├── fs.act
│ ├── hash/
│ │ ├── wyhash.act
│ │ └── wyhash.ext.c
│ ├── http.act
│ ├── json.act
│ ├── json.ext.c
│ ├── logging.act
│ ├── logging.ext.c
│ ├── math.act
│ ├── math.ext.c
│ ├── net.act
│ ├── net.ext.c
│ ├── process.act
│ ├── process.ext.c
│ ├── qcheck.act
│ ├── random.act
│ ├── random.ext.c
│ ├── re.act
│ ├── re.ext.c
│ ├── snappy.act
│ ├── snappy.ext.c
│ ├── term.act
│ ├── testing.act
│ ├── time.act
│ ├── time.ext.c
│ ├── uri.act
│ ├── xml.act
│ └── xml.ext.c
├── bin/
│ └── runacton
├── compiler/
│ ├── .gitignore
│ ├── CLAUDE.md
│ ├── acton/
│ │ ├── Main.hs
│ │ ├── PkgCommands.hs
│ │ ├── TerminalProgress.hs
│ │ ├── TerminalSize.hs
│ │ ├── TestFormat.hs
│ │ ├── TestGolden.hs
│ │ ├── TestRunner.hs
│ │ ├── TestUI.hs
│ │ ├── ZigProgress.hs
│ │ ├── package.yaml.in
│ │ ├── test/
│ │ │ ├── incremental_cases/
│ │ │ │ └── .gitignore
│ │ │ ├── parse/
│ │ │ │ ├── simple.act
│ │ │ │ ├── simple.all.golden
│ │ │ │ ├── simple.box.golden
│ │ │ │ ├── simple.cgen.golden
│ │ │ │ ├── simple.cps.golden
│ │ │ │ ├── simple.deact.golden
│ │ │ │ ├── simple.golden
│ │ │ │ ├── simple.hgen.golden
│ │ │ │ ├── simple.kinds.golden
│ │ │ │ ├── simple.llift.golden
│ │ │ │ ├── simple.norm.golden
│ │ │ │ ├── simple.sigs.golden
│ │ │ │ └── simple.types.golden
│ │ │ ├── project/
│ │ │ │ ├── auto_root/
│ │ │ │ │ ├── .gitignore
│ │ │ │ │ ├── Build.act
│ │ │ │ │ └── src/
│ │ │ │ │ ├── b.act
│ │ │ │ │ └── test.act
│ │ │ │ ├── conf_2bin/
│ │ │ │ │ ├── .gitignore
│ │ │ │ │ ├── Build.act
│ │ │ │ │ └── src/
│ │ │ │ │ ├── a.act
│ │ │ │ │ └── b.act
│ │ │ │ ├── missing_src/
│ │ │ │ │ ├── .gitignore
│ │ │ │ │ └── Build.act
│ │ │ │ ├── prune_executables/
│ │ │ │ │ ├── .gitignore
│ │ │ │ │ ├── Build.act
│ │ │ │ │ └── src/
│ │ │ │ │ ├── bar.act
│ │ │ │ │ ├── foo.act
│ │ │ │ │ └── tests/
│ │ │ │ │ └── simple.act
│ │ │ │ ├── prune_partials/
│ │ │ │ │ ├── .gitignore
│ │ │ │ │ ├── Build.act
│ │ │ │ │ └── src/
│ │ │ │ │ ├── bar.act
│ │ │ │ │ └── foo.act
│ │ │ │ ├── prune_roots/
│ │ │ │ │ ├── .gitignore
│ │ │ │ │ ├── Build.act
│ │ │ │ │ └── src/
│ │ │ │ │ └── foo.act
│ │ │ │ ├── qualified_root/
│ │ │ │ │ ├── .gitignore
│ │ │ │ │ ├── Build.act
│ │ │ │ │ └── src/
│ │ │ │ │ ├── b.act
│ │ │ │ │ └── test.act
│ │ │ │ └── simple/
│ │ │ │ ├── .gitignore
│ │ │ │ ├── Build.act
│ │ │ │ └── src/
│ │ │ │ ├── a.act
│ │ │ │ └── b.act
│ │ │ ├── rebuild/
│ │ │ │ ├── .gitignore
│ │ │ │ ├── Build.act
│ │ │ │ └── golden/
│ │ │ │ ├── file_02-initial-build.golden
│ │ │ │ ├── file_03-up-to-date.golden
│ │ │ │ ├── file_04-touch-no-rebuild.golden
│ │ │ │ ├── file_06-change-a-impl.golden
│ │ │ │ ├── file_08-change-b-impl.golden
│ │ │ │ ├── project_02-initial-build.golden
│ │ │ │ ├── project_03-up-to-date.golden
│ │ │ │ ├── project_04-touch-no-rebuild.golden
│ │ │ │ ├── project_06-change-a-impl.golden
│ │ │ │ ├── project_08-change-b-impl.golden
│ │ │ │ ├── project_10-change-a-iface.golden
│ │ │ │ ├── project_11-change-b-doc.golden
│ │ │ │ └── project_12-codegen-stale.golden
│ │ │ ├── root/
│ │ │ │ └── test.act
│ │ │ ├── syntaxerrors/
│ │ │ │ ├── err1.act
│ │ │ │ ├── err1.golden
│ │ │ │ ├── err10.act
│ │ │ │ ├── err10.golden
│ │ │ │ ├── err11.act
│ │ │ │ ├── err11.golden
│ │ │ │ ├── err12.act
│ │ │ │ ├── err12.golden
│ │ │ │ ├── err13.act
│ │ │ │ ├── err13.golden
│ │ │ │ ├── err14.act
│ │ │ │ ├── err14.golden
│ │ │ │ ├── err15.act
│ │ │ │ ├── err15.golden
│ │ │ │ ├── err16.act
│ │ │ │ ├── err16.golden
│ │ │ │ ├── err17.act
│ │ │ │ ├── err17.golden
│ │ │ │ ├── err18.act
│ │ │ │ ├── err18.golden
│ │ │ │ ├── err19.act
│ │ │ │ ├── err19.golden
│ │ │ │ ├── err2.act
│ │ │ │ ├── err2.golden
│ │ │ │ ├── err20.act
│ │ │ │ ├── err20.golden
│ │ │ │ ├── err21.act
│ │ │ │ ├── err21.golden
│ │ │ │ ├── err22.act
│ │ │ │ ├── err22.golden
│ │ │ │ ├── err23.act
│ │ │ │ ├── err23.golden
│ │ │ │ ├── err24.act
│ │ │ │ ├── err24.golden
│ │ │ │ ├── err25.act
│ │ │ │ ├── err25.golden
│ │ │ │ ├── err26.act
│ │ │ │ ├── err26.golden
│ │ │ │ ├── err27.act
│ │ │ │ ├── err27.golden
│ │ │ │ ├── err28.act
│ │ │ │ ├── err28.golden
│ │ │ │ ├── err29.act
│ │ │ │ ├── err29.golden
│ │ │ │ ├── err3.act
│ │ │ │ ├── err3.golden
│ │ │ │ ├── err30.act
│ │ │ │ ├── err30.golden
│ │ │ │ ├── err31.act
│ │ │ │ ├── err31.golden
│ │ │ │ ├── err32.act
│ │ │ │ ├── err32.golden
│ │ │ │ ├── err33.act
│ │ │ │ ├── err33.golden
│ │ │ │ ├── err34.act
│ │ │ │ ├── err34.golden
│ │ │ │ ├── err35.act
│ │ │ │ ├── err35.golden
│ │ │ │ ├── err36.act
│ │ │ │ ├── err36.golden
│ │ │ │ ├── err37.act
│ │ │ │ ├── err37.golden
│ │ │ │ ├── err38.act
│ │ │ │ ├── err38.golden
│ │ │ │ ├── err39.act
│ │ │ │ ├── err39.golden
│ │ │ │ ├── err4.act
│ │ │ │ ├── err4.golden
│ │ │ │ ├── err40.act
│ │ │ │ ├── err40.golden
│ │ │ │ ├── err41.act
│ │ │ │ ├── err41.golden
│ │ │ │ ├── err42.act
│ │ │ │ ├── err42.golden
│ │ │ │ ├── err5.act
│ │ │ │ ├── err5.golden
│ │ │ │ ├── err6.act
│ │ │ │ ├── err6.golden
│ │ │ │ ├── err7.act
│ │ │ │ ├── err7.golden
│ │ │ │ ├── err8.act
│ │ │ │ ├── err8.golden
│ │ │ │ ├── err9.act
│ │ │ │ └── err9.golden
│ │ │ └── typeerrors/
│ │ │ ├── actor_self_reserved_assignment.act
│ │ │ ├── actor_self_reserved_assignment.golden
│ │ │ ├── actor_self_reserved_constructor_param.act
│ │ │ ├── actor_self_reserved_constructor_param.golden
│ │ │ ├── actor_self_reserved_except_as.act
│ │ │ ├── actor_self_reserved_except_as.golden
│ │ │ ├── actor_self_reserved_loop_var.act
│ │ │ ├── actor_self_reserved_loop_var.golden
│ │ │ ├── actor_self_reserved_method_name.act
│ │ │ ├── actor_self_reserved_method_name.golden
│ │ │ ├── actor_self_reserved_method_param.act
│ │ │ ├── actor_self_reserved_method_param.golden
│ │ │ ├── actor_self_reserved_method_param2.act
│ │ │ ├── actor_self_reserved_method_param2.golden
│ │ │ ├── actor_self_reserved_variable.act
│ │ │ ├── actor_self_reserved_variable.golden
│ │ │ ├── ex1.act
│ │ │ ├── ex1.golden
│ │ │ ├── ex10.act
│ │ │ ├── ex10.golden
│ │ │ ├── ex11.act
│ │ │ ├── ex11.golden
│ │ │ ├── ex13.act
│ │ │ ├── ex13.golden
│ │ │ ├── ex14.act
│ │ │ ├── ex14.golden
│ │ │ ├── ex15.act
│ │ │ ├── ex15.golden
│ │ │ ├── ex16.act
│ │ │ ├── ex16.golden
│ │ │ ├── ex17.act
│ │ │ ├── ex17.golden
│ │ │ ├── ex18.act
│ │ │ ├── ex18.golden
│ │ │ ├── ex19.act
│ │ │ ├── ex19.golden
│ │ │ ├── ex2.act
│ │ │ ├── ex2.golden
│ │ │ ├── ex20.act
│ │ │ ├── ex20.golden
│ │ │ ├── ex21.act
│ │ │ ├── ex21.golden
│ │ │ ├── ex22.act
│ │ │ ├── ex22.golden
│ │ │ ├── ex23.act
│ │ │ ├── ex23.golden
│ │ │ ├── ex24.act
│ │ │ ├── ex24.golden
│ │ │ ├── ex25.act
│ │ │ ├── ex25.golden
│ │ │ ├── ex26.act
│ │ │ ├── ex26.golden
│ │ │ ├── ex27.act
│ │ │ ├── ex27.golden
│ │ │ ├── ex4.act
│ │ │ ├── ex4.golden
│ │ │ ├── ex5.act
│ │ │ ├── ex5.golden
│ │ │ ├── ex6.act
│ │ │ ├── ex6.golden
│ │ │ ├── ex7.act
│ │ │ ├── ex7.golden
│ │ │ ├── ex8.act
│ │ │ ├── ex8.golden
│ │ │ ├── ex9.act
│ │ │ ├── ex9.golden
│ │ │ ├── funargs1.act
│ │ │ ├── funargs1.golden
│ │ │ ├── funargs2.act
│ │ │ ├── funargs2.golden
│ │ │ ├── funargs3.act
│ │ │ ├── funargs3.golden
│ │ │ ├── funargs4.act
│ │ │ ├── funargs4.golden
│ │ │ ├── funargs5.act
│ │ │ ├── funargs5.golden
│ │ │ ├── funargs6.act
│ │ │ └── funargs6.golden
│ │ ├── test.hs
│ │ ├── test_incremental.hs
│ │ └── test_online.hs
│ ├── diagnose/
│ │ ├── .gitignore
│ │ ├── LICENSE
│ │ ├── PATCHES.md
│ │ ├── README.md
│ │ ├── diagnose.cabal
│ │ ├── hie.yaml
│ │ ├── nix/
│ │ │ ├── nixpkgs-pinned.nix
│ │ │ └── stack.nix
│ │ ├── package.yaml
│ │ ├── src/
│ │ │ ├── Data/
│ │ │ │ └── List/
│ │ │ │ └── Safe.hs
│ │ │ └── Error/
│ │ │ ├── Diagnose/
│ │ │ │ ├── Compat/
│ │ │ │ │ ├── Hints.hs
│ │ │ │ │ ├── Megaparsec.hs
│ │ │ │ │ └── Parsec.hs
│ │ │ │ ├── Diagnostic/
│ │ │ │ │ └── Internal.hs
│ │ │ │ ├── Diagnostic.hs
│ │ │ │ ├── Position.hs
│ │ │ │ ├── Pretty.hs
│ │ │ │ ├── Report/
│ │ │ │ │ └── Internal.hs
│ │ │ │ ├── Report.hs
│ │ │ │ └── Style.hs
│ │ │ └── Diagnose.hs
│ │ ├── stack.yaml
│ │ └── test/
│ │ ├── megaparsec/
│ │ │ ├── Instances.hs
│ │ │ ├── Repro6.hs
│ │ │ └── Spec.hs
│ │ ├── parsec/
│ │ │ ├── Repro2.hs
│ │ │ └── Spec.hs
│ │ └── rendering/
│ │ └── Spec.hs
│ ├── lib/
│ │ ├── bench/
│ │ │ ├── KindsBench.hs
│ │ │ └── TypesBench.hs
│ │ ├── package.yaml.in
│ │ ├── src/
│ │ │ ├── Acton/
│ │ │ │ ├── Boxing.hs
│ │ │ │ ├── BuildSpec.hs
│ │ │ │ ├── Builtin.hs
│ │ │ │ ├── CPS.hs
│ │ │ │ ├── CodeGen.hs
│ │ │ │ ├── CommandLineParser.hs
│ │ │ │ ├── Compile.hs
│ │ │ │ ├── Completion.hs
│ │ │ │ ├── Converter.hs
│ │ │ │ ├── Deactorizer.hs
│ │ │ │ ├── Diagnostics.hs
│ │ │ │ ├── DocPrinter.hs
│ │ │ │ ├── Env.hs
│ │ │ │ ├── Fingerprint.hs
│ │ │ │ ├── Hashing.hs
│ │ │ │ ├── Kinds.hs
│ │ │ │ ├── LambdaLifter.hs
│ │ │ │ ├── NameInfo.hs
│ │ │ │ ├── Names.hs
│ │ │ │ ├── Normalizer.hs
│ │ │ │ ├── Parser.hs
│ │ │ │ ├── Prim.hs
│ │ │ │ ├── Printer.hs
│ │ │ │ ├── QuickType.hs
│ │ │ │ ├── Solver.hs
│ │ │ │ ├── SourceProvider.hs
│ │ │ │ ├── Subst.hs
│ │ │ │ ├── Syntax.hs
│ │ │ │ ├── Testing.hs
│ │ │ │ ├── Transform.hs
│ │ │ │ ├── TypeEnv.hs
│ │ │ │ ├── Types.hs
│ │ │ │ └── WitKnots.hs
│ │ │ ├── InterfaceFiles.hs
│ │ │ ├── Pretty.hs
│ │ │ ├── SrcLocation.hs
│ │ │ ├── Text_Megaparsec_Expr.hs
│ │ │ └── Utils.hs
│ │ └── test/
│ │ ├── 1-parse/
│ │ │ ├── docstrings.input
│ │ │ ├── docstrings.output
│ │ │ ├── syntax1.input
│ │ │ └── syntax1.output
│ │ ├── 2-kinds/
│ │ │ ├── deact.input
│ │ │ └── deact.output
│ │ ├── 3-types/
│ │ │ ├── class_init_attrs/
│ │ │ │ ├── uninit_assert_uninit_attr.golden
│ │ │ │ ├── uninit_augmented_assign.golden
│ │ │ │ ├── uninit_basic.golden
│ │ │ │ ├── uninit_basic_inferred.golden
│ │ │ │ ├── uninit_elif_missing.golden
│ │ │ │ ├── uninit_for_loop.golden
│ │ │ │ ├── uninit_grandparent.golden
│ │ │ │ ├── uninit_grandparent2.golden
│ │ │ │ ├── uninit_inherited.golden
│ │ │ │ ├── uninit_init_in_method.golden
│ │ │ │ ├── uninit_loop_references_self.golden
│ │ │ │ ├── uninit_method_call.golden
│ │ │ │ ├── uninit_method_call_assign.golden
│ │ │ │ ├── uninit_method_reference.golden
│ │ │ │ ├── uninit_nested_function_escape.golden
│ │ │ │ ├── uninit_nested_function_with_self.golden
│ │ │ │ ├── uninit_nested_if.golden
│ │ │ │ ├── uninit_no_parent_init.golden
│ │ │ │ ├── uninit_notimpl_call_other.golden
│ │ │ │ ├── uninit_partial.golden
│ │ │ │ ├── uninit_return_early.golden
│ │ │ │ ├── uninit_self_attr_access.golden
│ │ │ │ ├── uninit_self_in_list.golden
│ │ │ │ ├── uninit_self_reference.golden
│ │ │ │ └── uninit_try_except.golden
│ │ │ ├── deact.input
│ │ │ ├── deact.output
│ │ │ ├── test_discovery.input
│ │ │ └── test_discovery.output
│ │ ├── 4-normalizer/
│ │ │ ├── deact.input
│ │ │ └── deact.output
│ │ ├── 5-deactorizer/
│ │ │ ├── deact.input
│ │ │ ├── deact.output
│ │ │ ├── deact_from_import.input
│ │ │ └── deact_from_import.output
│ │ ├── 6-cps/
│ │ │ ├── cps_andor.input
│ │ │ ├── cps_andor.output
│ │ │ ├── cps_optchain.input
│ │ │ ├── cps_optchain.output
│ │ │ ├── cps_volatiles.input
│ │ │ └── cps_volatiles.output
│ │ ├── 7-lambdalifting/
│ │ │ ├── deact.input
│ │ │ └── deact.output
│ │ ├── 8-boxing/
│ │ │ ├── deact.input
│ │ │ └── deact.output
│ │ ├── 9-codegen/
│ │ │ ├── deact.c
│ │ │ ├── deact.h
│ │ │ ├── deact.input
│ │ │ ├── ints.c
│ │ │ ├── ints.h
│ │ │ ├── ints.input
│ │ │ ├── lines.c
│ │ │ ├── lines.h
│ │ │ └── lines.input
│ │ ├── ActonSpec.hs
│ │ ├── doc-golden/
│ │ │ ├── bar-color.txt
│ │ │ ├── bar.html
│ │ │ ├── bar.md
│ │ │ ├── bar.txt
│ │ │ ├── foo-color.txt
│ │ │ ├── foo.html
│ │ │ ├── foo.md
│ │ │ └── foo.txt
│ │ ├── parser_golden/
│ │ │ ├── alternating_quotes_error.golden
│ │ │ ├── deep_nesting_error.golden
│ │ │ ├── error_at_end.golden
│ │ │ ├── error_at_start.golden
│ │ │ ├── error_in_middle.golden
│ │ │ ├── escaped_brace_error.golden
│ │ │ ├── fstring_empty_expression.golden
│ │ │ ├── fstring_empty_format_specifier.golden
│ │ │ ├── fstring_invalid_alignment.golden
│ │ │ ├── fstring_invalid_format.golden
│ │ │ ├── fstring_missing_expression.golden
│ │ │ ├── fstring_missing_precision_digits_error.golden
│ │ │ ├── fstring_triple_double_6quotes.golden
│ │ │ ├── fstring_triple_single_6quotes.golden
│ │ │ ├── fstring_unbalanced_format.golden
│ │ │ ├── fstring_unclosed_brace.golden
│ │ │ ├── hex_incomplete_in_interpolation.golden
│ │ │ ├── hex_incomplete_no_digits.golden
│ │ │ ├── hex_incomplete_one_digit.golden
│ │ │ ├── hex_invalid_char.golden
│ │ │ ├── invalid_after_align.golden
│ │ │ ├── invalid_after_precision.golden
│ │ │ ├── invalid_after_width.golden
│ │ │ ├── invalid_in_type_spec.golden
│ │ │ ├── mixed_quotes_unclosed.golden
│ │ │ ├── mixed_six_quotes_double.golden
│ │ │ ├── module_actor_before_import.golden
│ │ │ ├── module_call_before_import.golden
│ │ │ ├── module_class_before_import.golden
│ │ │ ├── module_dict_before_import.golden
│ │ │ ├── module_for_before_import.golden
│ │ │ ├── module_func_before_import.golden
│ │ │ ├── module_if_before_import.golden
│ │ │ ├── module_list_before_import.golden
│ │ │ ├── module_number_before_import.golden
│ │ │ ├── module_var_before_import.golden
│ │ │ ├── multiline_format_error.golden
│ │ │ ├── multiline_nested_error.golden
│ │ │ ├── multiline_unclosed.golden
│ │ │ ├── nested_bad_type_spec.golden
│ │ │ ├── nested_empty_format.golden
│ │ │ ├── nested_empty_inner.golden
│ │ │ ├── nested_invalid_align.golden
│ │ │ ├── nested_invalid_format.golden
│ │ │ ├── nested_unclosed_inner.golden
│ │ │ ├── nested_unclosed_outer.golden
│ │ │ ├── newline_in_expr.golden
│ │ │ ├── octal_invalid_char.golden
│ │ │ ├── octal_invalid_first_digit.golden
│ │ │ ├── octal_out_of_range.golden
│ │ │ ├── octal_out_of_range_in_fstring.golden
│ │ │ ├── raw_six_quotes.golden
│ │ │ ├── raw_triple_double_6quotes.golden
│ │ │ ├── raw_triple_single_6quotes.golden
│ │ │ ├── seven_double_quotes.golden
│ │ │ ├── six_double_quotes.golden
│ │ │ ├── six_single_quotes.golden
│ │ │ ├── slice_format_error.golden
│ │ │ ├── slice_invalid_step.golden
│ │ │ ├── slice_missing_bracket.golden
│ │ │ ├── slice_nested_error.golden
│ │ │ ├── slice_unclosed_bracket.golden
│ │ │ ├── string_empty_expression.golden
│ │ │ ├── string_invalid_format.golden
│ │ │ ├── string_missing_expression.golden
│ │ │ ├── string_unclosed_brace.golden
│ │ │ ├── tab_in_format.golden
│ │ │ ├── triple_double_10quotes.golden
│ │ │ ├── triple_double_6quotes.golden
│ │ │ ├── triple_double_7quotes.golden
│ │ │ ├── triple_double_8quotes.golden
│ │ │ ├── triple_nested_unclosed.golden
│ │ │ ├── triple_single_10quotes.golden
│ │ │ ├── triple_single_6quotes.golden
│ │ │ ├── triple_single_7quotes.golden
│ │ │ ├── triple_single_8quotes.golden
│ │ │ ├── tristring_unclosed_brace.golden
│ │ │ ├── unclosed_bytes_string.golden
│ │ │ ├── unclosed_bytes_string_single.golden
│ │ │ ├── unclosed_raw_bytes_string.golden
│ │ │ ├── unclosed_raw_bytes_string_single.golden
│ │ │ ├── unclosed_raw_string.golden
│ │ │ ├── unclosed_raw_string_single.golden
│ │ │ ├── unclosed_string.golden
│ │ │ ├── unclosed_string_triple.golden
│ │ │ ├── unicode_format_error.golden
│ │ │ ├── unicode_long_in_fstring.golden
│ │ │ ├── unicode_long_incomplete.golden
│ │ │ ├── unicode_long_invalid_char.golden
│ │ │ ├── unicode_long_no_digits.golden
│ │ │ ├── unicode_short_in_fstring.golden
│ │ │ ├── unicode_short_incomplete.golden
│ │ │ ├── unicode_short_invalid_char.golden
│ │ │ ├── unicode_short_no_digits.golden
│ │ │ ├── unknown_escape_in_fstring.golden
│ │ │ ├── unknown_escape_p.golden
│ │ │ ├── unknown_escape_with_interpolation.golden
│ │ │ └── unknown_escape_z.golden
│ │ └── src/
│ │ ├── bar.act
│ │ ├── class_init_attrs/
│ │ │ ├── init_actor.act
│ │ │ ├── init_actor_call.act
│ │ │ ├── init_after_loop.act
│ │ │ ├── init_after_statements.act
│ │ │ ├── init_after_while.act
│ │ │ ├── init_assert.act
│ │ │ ├── init_assert_with_self.act
│ │ │ ├── init_basic.act
│ │ │ ├── init_both_branches_with_raise.act
│ │ │ ├── init_conditional.act
│ │ │ ├── init_constant_condition.act
│ │ │ ├── init_delete.act
│ │ │ ├── init_elif_raise_after_assignment.act
│ │ │ ├── init_except_raise_after_assignment.act
│ │ │ ├── init_function_call.act
│ │ │ ├── init_grandparent_call.act
│ │ │ ├── init_inferred_only.act
│ │ │ ├── init_inherited.act
│ │ │ ├── init_loop_break.act
│ │ │ ├── init_loop_continue.act
│ │ │ ├── init_mixed_parent_self.act
│ │ │ ├── init_multiple.act
│ │ │ ├── init_multiple_except_handlers.act
│ │ │ ├── init_nested_function.act
│ │ │ ├── init_nested_function_call.act
│ │ │ ├── init_nested_if.act
│ │ │ ├── init_nested_if_raise.act
│ │ │ ├── init_no_init_uses_parent.act
│ │ │ ├── init_notimpl_call.act
│ │ │ ├── init_notimplemented.act
│ │ │ ├── init_parent_call.act
│ │ │ ├── init_raise_after_assignment.act
│ │ │ ├── init_self_attr_access.act
│ │ │ ├── init_self_attr_conditional.act
│ │ │ ├── init_self_attr_in_expr.act
│ │ │ ├── init_self_attr_in_loop.act
│ │ │ ├── init_self_attr_reference.act
│ │ │ ├── init_try_else_combined.act
│ │ │ ├── init_try_except.act
│ │ │ ├── init_try_except_finally.act
│ │ │ ├── init_try_except_raise.act
│ │ │ ├── init_try_finally.act
│ │ │ ├── init_try_inside_if.act
│ │ │ ├── uninit_assert_uninit_attr.act
│ │ │ ├── uninit_augmented_assign.act
│ │ │ ├── uninit_basic.act
│ │ │ ├── uninit_basic_inferred.act
│ │ │ ├── uninit_elif_missing.act
│ │ │ ├── uninit_for_loop.act
│ │ │ ├── uninit_grandparent.act
│ │ │ ├── uninit_grandparent2.act
│ │ │ ├── uninit_inherited.act
│ │ │ ├── uninit_init_in_method.act
│ │ │ ├── uninit_loop_references_self.act
│ │ │ ├── uninit_method_call.act
│ │ │ ├── uninit_method_call_assign.act
│ │ │ ├── uninit_method_reference.act
│ │ │ ├── uninit_nested_function_escape.act
│ │ │ ├── uninit_nested_function_with_self.act
│ │ │ ├── uninit_nested_if.act
│ │ │ ├── uninit_no_parent_init.act
│ │ │ ├── uninit_notimpl_call_other.act
│ │ │ ├── uninit_partial.act
│ │ │ ├── uninit_return_early.act
│ │ │ ├── uninit_self_attr_access.act
│ │ │ ├── uninit_self_in_list.act
│ │ │ ├── uninit_self_reference.act
│ │ │ └── uninit_try_except.act
│ │ ├── cps_andor.act
│ │ ├── cps_optchain.act
│ │ ├── cps_volatiles.act
│ │ ├── deact.act
│ │ ├── deact_from_import.act
│ │ ├── docstrings.act
│ │ ├── foo.act
│ │ ├── import_private.act
│ │ ├── import_private_a.act
│ │ ├── import_private_qualified.act
│ │ ├── ints.act
│ │ ├── lines.act
│ │ ├── syntax1.act
│ │ └── test_discovery.act
│ ├── lsp-server/
│ │ ├── Main.hs
│ │ └── package.yaml.in
│ ├── stack.yaml
│ ├── test/
│ │ └── .gitignore
│ ├── tests/
│ │ ├── Acton.hs
│ │ ├── ActonLevels.hs
│ │ ├── CPretty.hs
│ │ ├── ProtExtElim.hs
│ │ ├── TestTransform.hs
│ │ ├── actorring.act
│ │ ├── controller.act
│ │ ├── counter.act
│ │ ├── env.act
│ │ ├── env.c
│ │ ├── netconf.act
│ │ ├── newtuple.act
│ │ ├── pingpong.act
│ │ ├── records.act
│ │ ├── test.act
│ │ ├── test1.act
│ │ ├── test2.act
│ │ ├── test3.act
│ │ ├── test4.act
│ │ ├── test5.act
│ │ ├── test6.act
│ │ └── tuples.act
│ └── tools/
│ ├── ld-wrapper.sh
│ ├── zig-cc.sh
│ └── zig-cxx.sh
├── completion/
│ └── acton.bash-completion
├── debian/
│ ├── acton.bash-completion
│ ├── changelog.in
│ ├── control
│ ├── copyright
│ ├── rules
│ └── watch
├── docs/
│ ├── acton-dev-guide/
│ │ ├── .gitignore
│ │ ├── README.md
│ │ ├── book.toml
│ │ ├── mdbook-admonish.css
│ │ ├── src/
│ │ │ ├── SUMMARY.md
│ │ │ ├── builtins/
│ │ │ │ ├── ffi.md
│ │ │ │ ├── functions.md
│ │ │ │ ├── index.md
│ │ │ │ └── types.md
│ │ │ ├── compiler/
│ │ │ │ ├── imports_and_envs.md
│ │ │ │ ├── incremental_compilation.md
│ │ │ │ ├── index.md
│ │ │ │ ├── passes/
│ │ │ │ │ ├── boxing.md
│ │ │ │ │ ├── codegen.md
│ │ │ │ │ ├── cps.md
│ │ │ │ │ ├── deactorize.md
│ │ │ │ │ ├── index.md
│ │ │ │ │ ├── kinds.md
│ │ │ │ │ ├── lambda_lift.md
│ │ │ │ │ ├── normalize.md
│ │ │ │ │ ├── parse.md
│ │ │ │ │ └── type_check.md
│ │ │ │ ├── project_dependencies.md
│ │ │ │ └── test_cache.md
│ │ │ ├── design/
│ │ │ │ ├── capabilities.md
│ │ │ │ ├── concurrency.md
│ │ │ │ └── index.md
│ │ │ ├── getting_started/
│ │ │ │ ├── build.md
│ │ │ │ ├── debugging.md
│ │ │ │ ├── repo_layout.md
│ │ │ │ └── tests.md
│ │ │ ├── getting_started.md
│ │ │ ├── index.md
│ │ │ ├── runtime/
│ │ │ │ ├── actors.md
│ │ │ │ ├── index.md
│ │ │ │ ├── memory.md
│ │ │ │ └── scheduler.md
│ │ │ └── tooling/
│ │ │ ├── index.md
│ │ │ └── testing.md
│ │ ├── svgbob.css
│ │ └── theme/
│ │ ├── content-width.css
│ │ ├── sbscode.css
│ │ ├── sbscode_copy.js
│ │ ├── skill-slider.css
│ │ ├── skill-slider.js
│ │ ├── tabs.css
│ │ └── tabs.js
│ ├── acton-guide/
│ │ ├── .gitignore
│ │ ├── LANGUAGE_REVIEW.md
│ │ ├── README.md
│ │ ├── RUST_BOOK_COMPARISON.md
│ │ ├── book.toml
│ │ ├── mdbook-admonish.css
│ │ ├── src/
│ │ │ ├── SUMMARY.md
│ │ │ ├── actors/
│ │ │ │ ├── async_method_call.md
│ │ │ │ ├── attributes.md
│ │ │ │ ├── cleanup.md
│ │ │ │ ├── concurrency.md
│ │ │ │ ├── lifetime.md
│ │ │ │ ├── root.md
│ │ │ │ ├── self.md
│ │ │ │ ├── sequential.md
│ │ │ │ └── sync_method_call.md
│ │ │ ├── actors.md
│ │ │ ├── classes/
│ │ │ │ ├── inheritance.md
│ │ │ │ ├── initialization.md
│ │ │ │ └── intro.md
│ │ │ ├── collections/
│ │ │ │ ├── dicts.md
│ │ │ │ ├── lists.md
│ │ │ │ └── sets.md
│ │ │ ├── collections.md
│ │ │ ├── compilation/
│ │ │ │ └── incremental.md
│ │ │ ├── compilation.md
│ │ │ ├── control_flow/
│ │ │ │ ├── actors.md
│ │ │ │ ├── after_sleep.md
│ │ │ │ ├── for.md
│ │ │ │ ├── if_else.md
│ │ │ │ └── while.md
│ │ │ ├── control_flow.md
│ │ │ ├── environment/
│ │ │ │ ├── interactive_stdin.md
│ │ │ │ ├── stdin.md
│ │ │ │ └── variables.md
│ │ │ ├── environment.md
│ │ │ ├── ext/
│ │ │ │ └── integrating_c_library.md
│ │ │ ├── functions/
│ │ │ │ ├── actor_methods.md
│ │ │ │ └── higher_order.md
│ │ │ ├── functions.md
│ │ │ ├── hello/
│ │ │ │ ├── args.md
│ │ │ │ ├── running_tests.md
│ │ │ │ └── shebang.md
│ │ │ ├── hello.md
│ │ │ ├── index.md
│ │ │ ├── install.md
│ │ │ ├── install_tip.md
│ │ │ ├── language/
│ │ │ │ ├── bindings_scope.md
│ │ │ │ ├── comments.md
│ │ │ │ ├── common_programming_concepts.md
│ │ │ │ ├── environment_capabilities.md
│ │ │ │ ├── errors_exceptions.md
│ │ │ │ ├── expressions_operators.md
│ │ │ │ ├── missing_values_failures.md
│ │ │ │ ├── modeling_data_interfaces.md
│ │ │ │ ├── optionals_none.md
│ │ │ │ ├── organizing_code.md
│ │ │ │ └── state_concurrency.md
│ │ │ ├── language.md
│ │ │ ├── modules.md
│ │ │ ├── naming.md
│ │ │ ├── package_management.md
│ │ │ ├── pkg/
│ │ │ │ ├── add_dependency.md
│ │ │ │ ├── fetch_dependencies.md
│ │ │ │ ├── fingerprint.md
│ │ │ │ ├── local_dependencies.md
│ │ │ │ ├── override_dependency.md
│ │ │ │ ├── package_index.md
│ │ │ │ └── remove_dependency.md
│ │ │ ├── primitives/
│ │ │ │ ├── complex.md
│ │ │ │ ├── float.md
│ │ │ │ ├── integers.md
│ │ │ │ ├── scalars.md
│ │ │ │ └── tuples.md
│ │ │ ├── primitives.md
│ │ │ ├── projects/
│ │ │ │ └── directory_structure.md
│ │ │ ├── projects.md
│ │ │ ├── protocols/
│ │ │ │ ├── dispatch.md
│ │ │ │ └── intro.md
│ │ │ ├── rts.md
│ │ │ ├── security/
│ │ │ │ ├── capabilities.md
│ │ │ │ └── intro.md
│ │ │ ├── security.md
│ │ │ ├── stdlib/
│ │ │ │ ├── builtin_protocols/
│ │ │ │ │ ├── collection.md
│ │ │ │ │ ├── general.md
│ │ │ │ │ ├── hashable.md
│ │ │ │ │ └── numeric.md
│ │ │ │ ├── builtin_protocols.md
│ │ │ │ ├── math.md
│ │ │ │ ├── re.md
│ │ │ │ └── standard_library.md
│ │ │ ├── stdlib.md
│ │ │ ├── testing/
│ │ │ │ ├── async_actor_test.md
│ │ │ │ ├── env_test.md
│ │ │ │ ├── failures_errors.md
│ │ │ │ ├── flaky.md
│ │ │ │ ├── perf_record.md
│ │ │ │ ├── performance.md
│ │ │ │ ├── snapshot.md
│ │ │ │ ├── stress.md
│ │ │ │ ├── sync_actor_test.md
│ │ │ │ └── unit_test.md
│ │ │ ├── testing.md
│ │ │ ├── types/
│ │ │ │ ├── effects.md
│ │ │ │ ├── explicit.md
│ │ │ │ ├── generics.md
│ │ │ │ ├── intro.md
│ │ │ │ ├── optionals.md
│ │ │ │ └── troubleshooting.md
│ │ │ ├── working_with_zig.md
│ │ │ └── zig_dependencies.md
│ │ ├── svgbob.css
│ │ └── theme/
│ │ ├── acton-theme.css
│ │ ├── acton-theme.js
│ │ ├── content-width.css
│ │ ├── detail-toggles.css
│ │ ├── detail-toggles.js
│ │ ├── guide-links.css
│ │ ├── guide-links.js
│ │ ├── sbscode.css
│ │ ├── sbscode_copy.js
│ │ ├── tabs.css
│ │ └── tabs.js
│ ├── dev.md
│ ├── git-develop-workflow.md
│ ├── git-feature-workflow.md
│ ├── run-example.py
│ ├── triage.md
│ ├── tutorial/
│ │ ├── README.md
│ │ ├── example-0.md
│ │ ├── example-1.md
│ │ ├── example-2.md
│ │ └── example-3.md
│ └── wrapping_c_libraries.md
├── ecolift/
│ ├── CLAUDE.md
│ ├── repos/
│ │ └── .gitignore
│ └── string_interpolation.md
├── examples/
│ ├── .acton
│ ├── StringsAndBytes.act
│ ├── abs.act
│ ├── average.act
│ ├── bsplit.act
│ ├── client.act
│ ├── count.act
│ ├── counter.act
│ ├── eq_list_dict.act
│ ├── files.act
│ ├── helloworld.act
│ ├── http_server.act
│ ├── inter.act
│ ├── print_time.act
│ ├── reprtest.act
│ ├── server.act
│ ├── sieve.act
│ ├── sumto.act
│ └── worker.act
├── homebrew/
│ └── Formula/
│ └── acton.rb
├── slides/
│ └── ActonCompiler.pptx
├── test/
│ ├── .acton
│ ├── Makefile
│ └── count.act
├── utils/
│ ├── actonmon
│ ├── changelog-find-missing-link-defs.py
│ ├── lldb/
│ │ ├── README.md
│ │ └── acton.py
│ └── update-changelog.sh
├── version.mk
└── workspace/
├── MRO.hs
├── Plan-scribble.txt
├── Plan.txt
├── Semantics.txt
├── Type-hierarchy.act
├── Type-hierarchy.txt
├── Typesystem.txt
├── anomaly_detector/
│ ├── acton_anomaly_detector2.py
│ ├── acton_anomaly_detector3.py
│ ├── acton_anomaly_detector_demo.py
│ ├── acton_anomaly_detector_demo2.py
│ └── datasets/
│ └── selected/
│ ├── level_change/
│ │ ├── ambient_temperature_system_failure.csv
│ │ ├── ec2_cpu_utilization_825cc2.csv
│ │ ├── ec2_cpu_utilization_ac20cd.csv
│ │ ├── grok_asg_anomaly.csv
│ │ ├── rds_cpu_utilization_cc0c53.csv
│ │ └── rds_cpu_utilization_e47b3b.csv
│ ├── outliers/
│ │ ├── ec2_cpu_utilization_fe7f93.csv
│ │ └── rogue_agent_key_hold.csv
│ ├── seasonal/
│ │ ├── Twitter_volume_GOOG.csv
│ │ ├── art_daily_jumpsdown.csv
│ │ ├── art_daily_jumpsup.csv
│ │ ├── art_daily_jumpsup_noised.csv
│ │ ├── art_daily_jumpsup_noised_trended.csv
│ │ ├── art_daily_jumpsup_noised_trended_det.csv
│ │ ├── art_daily_jumpsup_noised_trended_det2.csv
│ │ ├── art_daily_jumpsup_noised_trended_det2_ts.csv
│ │ ├── art_daily_nojump.csv
│ │ ├── exchange-2_cpc_results.csv
│ │ ├── exchange-2_cpm_results.csv
│ │ ├── exchange-3_cpm_results.csv
│ │ ├── nyc_taxi.csv
│ │ ├── occupancy_6005.csv
│ │ └── occupancy_t4013.csv
│ ├── trending/
│ │ └── ambient_temperature_system_failure.csv
│ └── variance_change/
│ └── exchange-3_cpm_results.csv
├── concurrent_taskpool/
│ ├── Makefile
│ ├── src/
│ │ ├── Makefile
│ │ ├── concurrent_task_pool.h
│ │ ├── concurrent_task_pool_list.c
│ │ ├── concurrent_task_pool_tree.c
│ │ └── fastrand.h
│ └── tests_and_benchmarks/
│ ├── Makefile
│ ├── benchmarking_scripts/
│ │ ├── compare_old_new
│ │ ├── compare_settings
│ │ ├── get_series
│ │ ├── get_series_avg
│ │ ├── get_series_q
│ │ ├── get_series_r
│ │ ├── get_series_r_avg
│ │ ├── rank_param_settings
│ │ ├── rank_param_settings_d_h
│ │ ├── rank_param_settings_freqs
│ │ └── rank_param_settings_freqs_d_h
│ ├── concurrent_task_pool_test_multithreaded.c
│ └── concurrent_task_pool_test_multithreaded_mixed.c
├── micke/
│ ├── Makefile
│ ├── bytesview.c
│ ├── bytesview.h
│ ├── bytesview.py
│ ├── bytesview_test.c
│ ├── flow.txt
│ └── processing.txt
├── misc-examples/
│ ├── divtest.act
│ ├── loess_smoother.act
│ ├── loess_smoother3.act
│ ├── loess_smoother4.act
│ ├── loess_smoother5.act
│ ├── numpyfns.act
│ └── timestest.act
└── upgrades/
├── upgrade_v1
├── upgrade_v1.act
├── upgrade_v2
└── upgrade_v2.act
================================================
FILE CONTENTS
================================================
================================================
FILE: .containerignore
================================================
*
!dist
================================================
FILE: .github/ISSUE_TEMPLATE/blank_issue.md
================================================
---
name: Blank Issue
about: Create a blank issue.
---
================================================
FILE: .github/ISSUE_TEMPLATE/bug.yaml
================================================
name: "\U0001F41E Bug Report"
description: "Create a bug report for Acton."
labels: ["bug"]
body:
- type: markdown
attributes:
value: |
A bug is when something works differently than it is expected to.
## Remember to search before filing a new report
Please search for this bug in the issue tracker, and use a bug report title that would have made your bug report turn up in the search results for your search query.
- type: input
id: version
attributes:
label: Acton Version
description: "The output of `acton version`"
placeholder: "0.16.3"
validations:
required: true
- type: textarea
id: repro
attributes:
label: Steps to Reproduce and Observed Behavior
description: What exactly can someone else do, in order to observe the problem that you observed? Include the output and all error messages.
validations:
required: true
- type: textarea
id: expected
attributes:
label: Expected Behavior
description: What did you expect to happen instead?
validations:
required: true
================================================
FILE: .github/ISSUE_TEMPLATE/config.yml
================================================
blank_issues_enabled: true
contact_links:
- name: 🗣 Ask a Question, Discuss
url: https://github.com/actonlang/acton/discussions
about: Please ask and answer questions about Acton using GitHub discussions.
================================================
FILE: .github/ISSUE_TEMPLATE/feature.yaml
================================================
name: "\U0001F680 Feature / Enhancement Request"
description: "Suggest a new idea / feature enhancement for Acton."
labels: ["enhancement"]
body:
- type: markdown
attributes:
value: |
A feature is when you would like to add new functionality or change current functionality / behavior.
## Remember to search before filing a new report
Please search for this feature request in the issue tracker, and use a feature request title that would have made your feature request turn up in the search results for your search query.
- type: textarea
id: repro
attributes:
label: Proposal
description: Provide a clear and concise description of what you want
validations:
required: true
- type: textarea
id: expected
attributes:
label: Motivation
description: Explain the problem that your proposal is attempting to address
validations:
required: true
- type: textarea
id: actual
attributes:
label: Alternatives
description: What other solutions have you tried or considered?
validations:
required: true
================================================
FILE: .github/ISSUE_TEMPLATE/ice.yaml
================================================
name: "\U0001F4A5 Internal Compiler Error"
description: "Create a report for an Internal Compiler Error (ICE) in acton."
labels: ["bug", "Compiler"]
body:
- type: markdown
attributes:
value: |
We're sorry to hear you encountered an Internal Compiler Error and thank you for reporting it!
If possible, try to provide a minimal reproduction case.
- type: input
id: version
attributes:
label: Acton Version
description: "The output of `acton version`"
placeholder: "0.16.3"
validations:
required: true
- type: textarea
id: repro
attributes:
label: Reproduction code
description: What exactly can someone else do, in order to trigger the ICE?
placeholder: If possible, try to provide a minimal reproduction case.
validations:
required: true
- type: textarea
id: expected
attributes:
label: Error output
description: Include the full output from compiling using `acton`
placeholder: |
$ ../dist/acton counter_adder.act
/home/user/acton/dist/modules/test/counter_adder.c: In function ‘test$counter_adder$$Counter$count$local’:
/home/user/acton/dist/modules/test/counter_adder.c:224:9: error: conversion to non-scalar type requested
224 | return (($R)__self__->i);
| ^~~~~~
ERROR: internal compiler error: compilation of generated C code failed
NOTE: this is likely a bug in acton, please report this at:
NOTE: https://github.com/actonlang/acton/issues/new?template=ice.md
NOTE: acton 0.5.2.20210904.7.7.37
$
validations:
required: true
================================================
FILE: .github/dependabot.yml
================================================
# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates
version: 2
updates:
- package-ecosystem: "github-actions"
directory: "/" # Location of package manifests
schedule:
interval: "weekly"
================================================
FILE: .github/workflows/claude.yml
================================================
name: Claude Code
on:
issue_comment:
types: [created]
pull_request_review_comment:
types: [created]
issues:
types: [opened, assigned]
pull_request_review:
types: [submitted]
jobs:
claude:
if: |
(github.event_name == 'issue_comment' && contains(github.event.comment.body, '@claude')) ||
(github.event_name == 'pull_request_review_comment' && contains(github.event.comment.body, '@claude')) ||
(github.event_name == 'pull_request_review' && contains(github.event.review.body, '@claude')) ||
(github.event_name == 'issues' && (contains(github.event.issue.body, '@claude') || contains(github.event.issue.title, '@claude')))
runs-on: ubuntu-latest
permissions:
contents: read
pull-requests: read
issues: read
id-token: write
steps:
- name: Checkout repository
uses: actions/checkout@v6
with:
fetch-depth: 1
- name: Run Claude Code
id: claude
uses: anthropics/claude-code-action@beta
with:
anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
================================================
FILE: .github/workflows/code-agent.yml
================================================
name: Code Agent
permissions:
contents: write
pull-requests: write
issues: write
on:
issues:
types: [opened]
issue_comment:
types: [created]
pull_request_review_comment:
types: [created]
jobs:
code-agent:
runs-on: ubuntu-latest
if: ${{ github.event.sender.type != 'Bot' }}
steps:
- uses: potproject/code-agent@main
with:
github-token: ${{ secrets.GITHUB_TOKEN }}
# [Claude Code Settings]
anthropic-api-key: ${{ secrets.ANTHROPIC_API_KEY }}
# [Optional Claude Code Settings]
# anthropic-base-url: "https://api.anthropic.com"
# anthropic-model: "claude-3-7-sonnet-20250219"
# anthropic-small-fast-model: "claude-3-5-haiku-20241022"
# claude-code-use-bedrock: "1"
# anthropic-bedrock-base-url: "https://bedrock.us-east-1.amazonaws.com"
# aws-access-key-id: ${{ secrets.AWS_ACCESS_KEY_ID }}
# aws-secret-access-key: ${{ secrets.AWS_SECRET_ACCESS_KEY }}
# aws-region: "us-east-1"
# disable-prompt-caching: "1"
# [Codex Settings]
openai-api-key: ${{ secrets.OPENAI_API_KEY }}
# [Optional Codex Settings]
# openai-base-url: "https://api.openai.com"
================================================
FILE: .github/workflows/create-release.yml
================================================
name: Create Release Branch
on:
workflow_dispatch:
inputs:
release_type:
description: 'Release Type'
required: true
type: choice
options:
- major
- minor
- patch
default: 'patch'
jobs:
create-release-branch:
runs-on: ubuntu-latest
steps:
- name: Checkout code
uses: actions/checkout@v6
with:
ssh-key: ${{ secrets.ACTONBOT_DEPLOY_KEY }}
fetch-depth: 0
- name: Set up Git user
run: |
git config user.name "Acton Bot"
git config user.email apt@acton-lang.org
- name: Get current version
id: current_version
run: |
VERSION=$(grep "^VERSION=" version.mk | cut -d= -f2)
echo "Current version: $VERSION"
echo "version=$VERSION" >> $GITHUB_OUTPUT
# Split version
MAJOR=$(echo $VERSION | cut -d. -f1)
MINOR=$(echo $VERSION | cut -d. -f2)
PATCH=$(echo $VERSION | cut -d. -f3)
echo "major=$MAJOR" >> $GITHUB_OUTPUT
echo "minor=$MINOR" >> $GITHUB_OUTPUT
echo "patch=$PATCH" >> $GITHUB_OUTPUT
- name: Calculate new version
id: new_version
run: |
MAJOR=${{ steps.current_version.outputs.major }}
MINOR=${{ steps.current_version.outputs.minor }}
PATCH=${{ steps.current_version.outputs.patch }}
if [[ "${{ github.event.inputs.release_type }}" == "major" ]]; then
MAJOR=$((MAJOR + 1))
MINOR=0
PATCH=0
elif [[ "${{ github.event.inputs.release_type }}" == "minor" ]]; then
MINOR=$((MINOR + 1))
PATCH=0
else # patch
PATCH=$((PATCH + 1))
fi
NEW_VERSION="${MAJOR}.${MINOR}.${PATCH}"
echo "New version: $NEW_VERSION"
echo "version=$NEW_VERSION" >> $GITHUB_OUTPUT
- name: Update version in version.mk
run: |
NEW_VERSION=${{ steps.new_version.outputs.version }}
sed -i "s/^VERSION=.*/VERSION=${NEW_VERSION}/" version.mk
- name: Update CHANGELOG.md
run: |
NEW_VERSION=${{ steps.new_version.outputs.version }}
TODAY=$(date +%Y-%m-%d)
# Replace [Unreleased] with the new version
sed -i "s/## \[Unreleased\]/## [${NEW_VERSION}] - ${TODAY}/" CHANGELOG.md
- name: Create and push release branch
run: |
NEW_VERSION=${{ steps.new_version.outputs.version }}
BRANCH_NAME="release-v${NEW_VERSION}"
git checkout -b $BRANCH_NAME
git add version.mk CHANGELOG.md
git commit -m "Release version ${NEW_VERSION}"
git push origin $BRANCH_NAME
echo "::notice::Created release branch $BRANCH_NAME with version $NEW_VERSION"
- name: Create pull request
env:
GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
NEW_VERSION=${{ steps.new_version.outputs.version }}
BRANCH_NAME="release-v${NEW_VERSION}"
gh pr create \
--title "Release v${NEW_VERSION}" \
--base main \
--head $BRANCH_NAME \
--body "This PR updates the version to ${NEW_VERSION} and prepares the CHANGELOG.md for release."
================================================
FILE: .github/workflows/release.yml
================================================
name: Add git tag for release
on:
pull_request:
types:
- closed
jobs:
if_merged:
# name should be e.g. release-v1.2.3
if: ${{ startsWith(github.head_ref, 'release-v') && github.event.pull_request.merged == true }}
runs-on: ubuntu-latest
steps:
- run: |
echo The PR was merged
- name: "Check out repository code"
uses: actions/checkout@v6
with:
ssh-key: ${{ secrets.ACTONBOT_DEPLOY_KEY }}
- name: "Get the version"
id: get_version
run: echo "version=$(grep VERSION= version.mk | cut -d = -f 2)" >> $GITHUB_OUTPUT
- name: "Add version tag and push"
run: |
git config user.name "Apt Bot"
git config user.email apt@acton-lang.org
git tag v${{steps.get_version.outputs.version}}
git push origin v${{steps.get_version.outputs.version}}
================================================
FILE: .github/workflows/test-app.yml
================================================
on:
workflow_call:
inputs:
repo_url:
required: true
type: string
arch:
required: false
type: string
default: "amd64"
jobs:
test-app:
runs-on: ubuntu-24.04${{ inputs.arch == 'arm64' && '-arm' || '' }}
steps:
- name: "Install gdb"
run: |
sudo apt update
sudo apt install -y gdb
- name: "Download .deb files"
uses: actions/download-artifact@v8
with:
name: acton-debs-${{ inputs.arch }}
- name: "Install acton from .deb"
run: |
sudo apt install -y ./deb/acton_*.deb
acton version
- name: "Clone app repo"
uses: actions/checkout@v6
with:
repository: ${{ inputs.repo_url }}
path: app
- name: "Compile acton program"
run: |
cd app
acton build
acton test
acton test perf
================================================
FILE: .github/workflows/test.yml
================================================
name: Build, Test & Release
# Build, Test & Release (BTR) run for:
# - pushes to the main branch
# - new tags are pushed
# - for pull requests
#
# Releases are tagged with vX.Y.Z. We determine if we are building for a release
# or not by looking if the tag name starts with 'v'.
#
# To release:
# - create new branch using name: release-vX.Y.Z
# - update version in version.mk
# - update CHANGELOG.md, second entry must equal version in version.mk
# - first entry is assumed to be "Unreleased"
# - push a tag like vX.Y.Z which is equal to version in version.mk
#
on:
pull_request:
push:
branches:
- main
tags:
- v*
schedule:
# Schedule to run daily
- cron: '4 0 * * *'
env:
ZIG_DOWNLOAD_BASE_URL: https://github.com/actonlang/zigballs/raw/main
# NOTE: Jobs for version tagged releases just pattern match on any tag starting
# with 'v'. That's probably a version tag, but could be something else. Is there
# a better way to match?
jobs:
build-version:
runs-on: ubuntu-latest
outputs:
build_time: ${{ steps.setver.outputs.build_time }}
steps:
- name: "Set consistent build time"
id: setver
run: echo "build_time=$(date -u '+%Y%m%d.%-H.%-M')" >> "$GITHUB_OUTPUT"
matrix_maker_macos:
runs-on: ubuntu-latest
outputs:
matrix: ${{ steps.setmatrix.outputs.matrix }}
steps:
- name: "Set Matrix for PR or push"
# Keep PR matrix minimal; extra entries increase cache pressure and slow PR workflows.
if: github.event_name != 'schedule'
id: setmatrix_pr
run: |
MATRIX_JSON='{\"include\":[{\"os\":\"macos\",\"version\":\"15\",\"arch\":\"aarch64\",\"cache\":true},{\"os\":\"macos\",\"version\":\"15\",\"arch\":\"x86_64\",\"cache\":true},{\"os\":\"macos\",\"version\":\"26\",\"arch\":\"aarch64\",\"cache\":true}]}'
echo "matrix=$MATRIX_JSON" >> $GITHUB_OUTPUT
- name: "Set Matrix for nightly run"
if: github.event_name == 'schedule'
id: setmatrix_cron
run: |
MATRIX_JSON='{\"include\":[{\"os\":\"macos\",\"version\":\"15\",\"arch\":\"aarch64\",\"cache\":true},{\"os\":\"macos\",\"version\":\"15\",\"arch\":\"x86_64\",\"cache\":true},{\"os\":\"macos\",\"version\":\"26\",\"arch\":\"aarch64\",\"cache\":true}]}'
echo "matrix=$MATRIX_JSON" >> $GITHUB_OUTPUT
- name: "Set final matrix output"
id: setmatrix
run: |
if [ "${{ github.event_name }}" == "schedule" ]; then
echo "matrix=${{ steps.setmatrix_cron.outputs.matrix }}" >> $GITHUB_OUTPUT
else
echo "matrix=${{ steps.setmatrix_pr.outputs.matrix }}" >> $GITHUB_OUTPUT
fi
- name: "Debug: Print matrix JSON"
run: |
echo "Matrix JSON:"
echo '${{ toJson(fromJson(steps.setmatrix.outputs.matrix)) }}'
echo "Event name: ${{ github.event_name }}"
test-macos:
needs: [build-version, matrix_maker_macos]
strategy:
fail-fast: false
matrix: ${{ fromJson(needs.matrix_maker_macos.outputs.matrix) }}
runs-on: ${{ (matrix.version == '15' && matrix.arch == 'x86_64') && 'macos-15-intel' || format('{0}-{1}', matrix.os, matrix.version) }}
env:
BUILD_TIME: ${{ needs.build-version.outputs.build_time }}
steps:
- name: "Show env"
run: env
- name: "Set BUILD_RELEASE when we are building for a version tag"
run: |
echo "BUILD_RELEASE=1" >> $GITHUB_ENV
if: startsWith(github.ref, 'refs/tags/v')
- name: "Enable dumping core files"
run: |
sudo sysctl kern.corefile=core.%P
ulimit -c unlimited
- name: "Check out repository code"
uses: actions/checkout@v6
- name: "Cache stuff"
if: matrix.cache == true
uses: actions/cache@v5
with:
path: |
~/.stack
key: test-${{ matrix.os }}-${{ matrix.version }}-${{ matrix.arch }}-${{ hashFiles('compiler/stack.yaml', 'compiler/stack.yaml.lock', 'Makefile', 'compiler/tools/*.sh') }}
- name: "Cache Acton"
if: matrix.cache == true
uses: actions/cache@v5
with:
path: |
~/.cache/acton/
key: test-${{ matrix.os }}-${{ matrix.version }}-${{ matrix.arch }}-acton
- name: "Install build prerequisites"
run: brew install haskell-stack
- name: "Build Acton"
run: |
make -j2 -C ${{ github.workspace }} BUILD_RELEASE=${{ env.BUILD_RELEASE }} BUILD_TIME=${BUILD_TIME}
- name: "Build a release"
run: make -C ${{ github.workspace }} release BUILD_TIME=${BUILD_TIME}
- name: "Upload artifact"
uses: actions/upload-artifact@v7
with:
name: acton-${{ matrix.os }}-${{ matrix.version }}-${{ matrix.arch }}
path: ${{ github.workspace }}/acton-*
if-no-files-found: error
- name: "Run tests"
env:
# Package manager uses token to make authenticated requests to GitHub REST API, avoiding rate limits
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
ulimit -c unlimited
make -C ${{ github.workspace }} test
make -C ${{ github.workspace }} online-tests
- name: "Upload whole test dir as artifact on test failure"
if: failure()
uses: actions/upload-artifact@v7
with:
name: test-debug-${{ matrix.os }}-${{ matrix.version }}-${{ matrix.arch }}-${{ github.run_id }}.zip
path: |
${{ github.workspace }}/test
matrix_maker_linux:
runs-on: ubuntu-latest
outputs:
matrix: ${{ steps.setmatrix.outputs.matrix }}
steps:
- name: "Set Matrix for PR or push"
# Keep PR matrix minimal; extra entries increase cache pressure and slow PR workflows.
if: github.event_name != 'schedule'
id: setmatrix_pr
run: |
MATRIX_JSON='{\"include\":[{\"os\":\"debian\",\"version\":\"11\",\"arch\":\"x86_64\",\"cache\":true},{\"os\":\"ubuntu\",\"version\":\"24.04\",\"arch\":\"arm64v8\",\"cache\":true}]}'
echo "matrix=$MATRIX_JSON" >> $GITHUB_OUTPUT
- name: "Set Matrix for nightly run"
if: github.event_name == 'schedule'
id: setmatrix_cron
run: |
MATRIX_JSON='{\"include\":[{\"os\":\"debian\",\"version\":\"11\",\"arch\":\"x86_64\",\"cache\":true},{\"os\":\"debian\",\"version\":\"12\",\"arch\":\"x86_64\",\"cache\":false},{\"os\":\"debian\",\"version\":\"13\",\"arch\":\"x86_64\",\"cache\":false},{\"os\":\"ubuntu\",\"version\":\"22.04\",\"arch\":\"x86_64\",\"cache\":false},{\"os\":\"ubuntu\",\"version\":\"24.04\",\"arch\":\"x86_64\",\"cache\":false},{\"os\":\"ubuntu\",\"version\":\"24.04\",\"arch\":\"arm64v8\",\"cache\":true}]}'
echo "matrix=$MATRIX_JSON" >> $GITHUB_OUTPUT
- name: "Set final matrix output"
id: setmatrix
run: |
if [ "${{ github.event_name }}" == "schedule" ]; then
echo "matrix=${{ steps.setmatrix_cron.outputs.matrix }}" >> $GITHUB_OUTPUT
else
echo "matrix=${{ steps.setmatrix_pr.outputs.matrix }}" >> $GITHUB_OUTPUT
fi
- name: "Debug: Print matrix JSON"
run: |
echo "Matrix JSON:"
echo '${{ toJson(fromJson(steps.setmatrix.outputs.matrix)) }}'
echo "Event name: ${{ github.event_name }}"
test-linux:
needs: [build-version, matrix_maker_linux]
strategy:
fail-fast: false
matrix: ${{ fromJson(needs.matrix_maker_linux.outputs.matrix) }}
runs-on: ubuntu-24.04${{ matrix.arch == 'arm64v8' && '-arm' || '' }}
container:
image: ${{ matrix.os }}:${{ matrix.version }}
env:
LANG: en_US.UTF-8
LC_ALL: en_US.UTF-8
BUILD_TIME: ${{ needs.build-version.outputs.build_time }}
steps:
- name: "Show platform and environment"
run: |
uname -a
env
cat /proc/cpuinfo
- name: "Set BUILD_RELEASE when we are building for a version tag"
if: startsWith(github.ref, 'refs/tags/v')
run: |
echo "BUILD_RELEASE=1" >> $GITHUB_ENV
- name: "Check out repository code"
uses: actions/checkout@v6
- name: "Cache stuff"
if: matrix.cache == true
uses: actions/cache@v5
with:
path: |
~/.stack
key: test-${{ matrix.os }}-${{ matrix.version }}-${{ matrix.arch }}-${{ hashFiles('compiler/stack.yaml', 'compiler/stack.yaml.lock', 'Makefile', 'compiler/tools/*.sh') }}
- name: "chown our home dir to avoid stack complaining"
run: chown -R root:root /github/home
- name: "Install build prerequisites"
run: |
export DEBIAN_FRONTEND=noninteractive
apt-get update
apt-get install -qy bzip2 curl g++ haskell-stack libgmp-dev libncurses-dev make procps zlib1g-dev
apt-get install -qy gdb
- name: "locale en_US.UTF-8"
run: |
apt-get install -qy locales
locale-gen en_US.UTF-8
echo "locales locales/default_environment_locale select en_US.UTF-8" | debconf-set-selections
echo "locales locales/locales_to_be_generated multiselect en_US.UTF-8 UTF-8" | debconf-set-selections
rm "/etc/locale.gen"
dpkg-reconfigure --frontend noninteractive locales
- name: "Install newer stack"
run: |
STACK_VERSION=3.9.3
ARCH="$(uname -m)"
case "${ARCH}" in
x86_64) STACK_ARCH="x86_64" ;;
aarch64|arm64) STACK_ARCH="aarch64" ;;
*) echo "Unsupported arch: ${ARCH}" >&2; exit 1 ;;
esac
STACK_TAR="stack-${STACK_VERSION}-linux-${STACK_ARCH}.tar.gz"
STACK_URL="https://github.com/commercialhaskell/stack/releases/download/v${STACK_VERSION}/${STACK_TAR}"
mkdir -p "${HOME}/.local/bin"
curl -fsSL "${STACK_URL}" -o /tmp/stack.tgz
tar -xzf /tmp/stack.tgz -C /tmp
install -m 0755 "/tmp/stack-${STACK_VERSION}-linux-${STACK_ARCH}/stack" "${HOME}/.local/bin/stack"
echo "${HOME}/.local/bin" >> "$GITHUB_PATH"
"${HOME}/.local/bin/stack" --version
- name: "Use container glibc target for source build"
run: |
GLIBC_VERSION="$(getconf GNU_LIBC_VERSION | awk '{print $2}')"
echo "ACTON_ZIG_GLIBC_VERSION=${GLIBC_VERSION}" >> "$GITHUB_ENV"
echo "Using Zig glibc target ${GLIBC_VERSION}"
- name: "Build Acton"
run: |
make -j2 -C ${GITHUB_WORKSPACE} BUILD_RELEASE=${{ env.BUILD_RELEASE }} BUILD_TIME=${BUILD_TIME}
- name: "Build a release"
run: make -C ${GITHUB_WORKSPACE} release BUILD_TIME=${BUILD_TIME}
- name: "Upload artifact"
uses: actions/upload-artifact@v7
with:
name: acton-${{ matrix.os }}-${{ matrix.version }}-${{ matrix.arch }}
path: ${{ github.workspace }}/acton-*
if-no-files-found: error
- name: "Run tests"
run: |
ulimit -c unlimited
make -C ${GITHUB_WORKSPACE} test
make -C ${GITHUB_WORKSPACE} online-tests
- name: "Upload whole test dir as artifact on test failure"
if: failure()
uses: actions/upload-artifact@v7
with:
name: test-debug-${{ matrix.os }}-${{ matrix.version }}-${{ matrix.arch }}-${{ github.run_id }}.zip
path: |
${{ github.workspace }}/test
build-debs:
needs: build-version
strategy:
fail-fast: false
matrix:
arch: [amd64, arm64]
runs-on: ${{ matrix.arch == 'amd64' && 'ubuntu-24.04' || 'ubuntu-24.04-arm' }}
container:
image: debian:11
env:
LANG: en_US.UTF-8
LC_ALL: en_US.UTF-8
BUILD_TIME: ${{ needs.build-version.outputs.build_time }}
HOME: /tmp/acton-gh-home
STACK_ROOT: /tmp/acton-gh-home/.stack
steps:
- name: "Show platform and environment"
run: |
env
ldd --version | head -n1
cat /proc/cpuinfo
uname -a
- name: "Set BUILD_RELEASE when we are building for a version tag"
run: |
echo "BUILD_RELEASE=1" >> $GITHUB_ENV
if: startsWith(github.ref, 'refs/tags/v')
- name: "Install build prerequisites"
run: |
apt-get update
apt-get install -qy bzip2 curl g++ haskell-stack libgmp-dev libncurses-dev make procps zlib1g-dev
apt-get install -qy bash-completion build-essential debhelper devscripts
- name: "Prepare stack directories"
run: |
mkdir -p "${HOME}/.local/bin" "${STACK_ROOT}"
- name: "Check out repository code"
uses: actions/checkout@v6
- name: "Cache stuff"
uses: actions/cache@v5
with:
path: |
${{ env.STACK_ROOT }}
key: build-debs-${{ matrix.arch }}-${{ hashFiles('compiler/stack.yaml', 'compiler/stack.yaml.lock', 'Makefile', 'compiler/tools/*.sh', 'debian/control') }}
- name: "locale en_US.UTF-8"
run: |
apt-get install -qy locales
locale-gen en_US.UTF-8
echo "locales locales/default_environment_locale select en_US.UTF-8" | debconf-set-selections
echo "locales locales/locales_to_be_generated multiselect en_US.UTF-8 UTF-8" | debconf-set-selections
rm "/etc/locale.gen"
dpkg-reconfigure --frontend noninteractive locales
- name: "Install newer stack"
run: |
STACK_VERSION=3.9.3
ARCH="$(uname -m)"
case "${ARCH}" in
x86_64) STACK_ARCH="x86_64" ;;
aarch64|arm64) STACK_ARCH="aarch64" ;;
*) echo "Unsupported arch: ${ARCH}" >&2; exit 1 ;;
esac
STACK_TAR="stack-${STACK_VERSION}-linux-${STACK_ARCH}.tar.gz"
STACK_URL="https://github.com/commercialhaskell/stack/releases/download/v${STACK_VERSION}/${STACK_TAR}"
curl -fsSL "${STACK_URL}" -o /tmp/stack.tgz
tar -xzf /tmp/stack.tgz -C /tmp
install -m 0755 "/tmp/stack-${STACK_VERSION}-linux-${STACK_ARCH}/stack" "${HOME}/.local/bin/stack"
echo "${HOME}/.local/bin" >> "$GITHUB_PATH"
"${HOME}/.local/bin/stack" --version
- name: "Build Debian packages"
shell: bash
run: |
set -euo pipefail
make -C "${GITHUB_WORKSPACE}" debs BUILD_RELEASE=${{ env.BUILD_RELEASE }} BUILD_TIME=${BUILD_TIME}
- name: "Show packaged Acton linkage"
shell: bash
run: |
set -euo pipefail
make -C "${GITHUB_WORKSPACE}" ldd
deb="$(ls "${GITHUB_WORKSPACE}"/../acton_*.deb | head -n1)"
dpkg-deb -I "$deb"
tmp="$(mktemp -d)"
dpkg-deb -x "$deb" "$tmp"
bins="$tmp/usr/lib/acton/bin/acton"
bins="$bins $tmp/usr/lib/acton/bin/lsp-server-acton"
bins="$bins $tmp/usr/lib/acton/bin/actondb"
make -C "${GITHUB_WORKSPACE}" ldd ACTON_LINKAGE_BINS="$bins"
- name: "Compute variables"
id: vars
run: |
echo "debdir=$(realpath ${GITHUB_WORKSPACE}/../deb)" >> $GITHUB_OUTPUT
echo "artifact_dir=$(dirname ${{ github.workspace }})" >> $GITHUB_OUTPUT
- name: "Move deb files into place for easy artifact extraction"
run: |
mkdir -p ${{ steps.vars.outputs.debdir }}
ls ${{ steps.vars.outputs.debdir }}/../
mv ${{ steps.vars.outputs.debdir }}/../acton_* ${{ steps.vars.outputs.debdir }}/
- name: "Upload artifact"
uses: actions/upload-artifact@v7
with:
name: acton-debs-${{ matrix.arch }}
# Using a wildcard and then deb here to force the entire directory to
# be part of resulting artifact.
path: ${{ steps.vars.outputs.artifact_dir }}/*deb/
if-no-files-found: error
run-macos:
needs: test-macos
strategy:
fail-fast: false
matrix:
os: [macos-15, macos-15-intel, macos-26]
runs-on: ${{ matrix.os }}
steps:
- name: "Machine info"
run: |
uname -a
system_profiler SPHardwareDataType
- name: "Download artifacts for Macos arm64, built on macos-15"
if: ${{ matrix.os == 'macos-15' || matrix.os == 'macos-26' }}
uses: actions/download-artifact@v8
with:
name: acton-macos-15-aarch64
- name: "Download artifacts for Macos x86_64, built on macos-15"
if: ${{ matrix.os == 'macos-15-intel' }}
uses: actions/download-artifact@v8
with:
name: acton-macos-15-x86_64
- name: "Extract acton"
run: |
tar Jxf $(ls acton-macos-*.tar.xz | tail -n1)
- name: "Compile acton program"
run: |
export PATH=$(pwd)/acton/bin:$PATH
acton version
echo '#!/usr/bin/env runacton' > acton-test.act
echo 'actor main(env):' >> acton-test.act
echo ' print("Hello, world")' >> acton-test.act
echo ' env.exit(0)' >> acton-test.act
chmod a+x acton-test.act
./acton-test.act
./acton-test.act | grep "Hello, world"
acton build acton-test.act
./acton-test
./acton-test | grep "Hello, world"
run-linux:
needs: build-debs
strategy:
fail-fast: false
matrix:
include:
- os: "debian"
version: "11"
arch: "amd64"
- os: "debian"
version: "12"
arch: "amd64"
- os: "ubuntu"
version: "20.04"
arch: "amd64"
- os: "ubuntu"
version: "22.04"
arch: "amd64"
- os: "ubuntu"
version: "24.04"
arch: "amd64"
- os: "ubuntu"
version: "24.04"
arch: "arm64"
- os: "ubuntu"
version: "24.04"
arch: "amd64"
target: "x86_64-linux-musl"
- os: "ubuntu"
version: "24.04"
arch: "arm64"
target: "aarch64-linux-musl"
env:
# This makes it possible for the GitHub Action itself to run using an
# older version of node, which is the only possibility to get it running
# on Ubuntu 18.04 (in the matrix above)
ACTIONS_RUNNER_FORCE_ACTIONS_NODE_VERSION: node16
ACTIONS_ALLOW_USE_UNSECURE_NODE_VERSION: true
runs-on: ${{ matrix.arch == 'amd64' && 'ubuntu-latest' || 'ubuntu-24.04-arm' }}
container:
image: ${{ matrix.os }}:${{ matrix.version }}
options: --privileged --ulimit core=-1 --security-opt seccomp=unconfined
steps:
- name: "Show platform and environment"
run: |
env
cat /proc/cpuinfo
- name: "Download .deb files"
uses: actions/download-artifact@v8
with:
name: acton-debs-${{ matrix.arch }}
- name: "Install acton from .deb"
run: |
apt update
apt install -y ./deb/acton_*.deb
acton version
- name: "Enable dumping core files to /tmp/core..."
run: |
apt install -qy procps
cat /proc/sys/kernel/core_pattern
sysctl kernel.core_pattern='/tmp/core.%h.%e.%t' || true
cat /proc/sys/kernel/core_pattern
ulimit -c unlimited
- name: "Compile acton program"
run: |
echo '#!/usr/bin/env runacton' > acton-test.act
echo 'actor main(env):' >> acton-test.act
echo ' print("Hello, world")' >> acton-test.act
echo ' env.exit(0)' >> acton-test.act
chmod a+x acton-test.act
./acton-test.act
./acton-test.act | grep "Hello, world"
acton build ${{ matrix.target && format('--target {0}', matrix.target) || '' }} acton-test.act
./acton-test
./acton-test | grep "Hello, world"
- name: "ls core"
if: failure()
run: |
pwd
ls
find /tmp
mv /tmp/core* .
- name: "Upload core file & binaries as artifacts on test failure"
if: failure()
uses: actions/upload-artifact@v7
with:
name: coredumps-${{ matrix.os }}-${{ matrix.version }}-${{ github.run_id }}.zip
path: |
${{ github.workspace }}/core*
perf-vs-main:
needs: build-debs
# Use our own runner to get more deterministic results
runs-on: [self-hosted, linux, X64]
steps:
- name: "Check out repository code"
uses: actions/checkout@v6
- name: "Remove any currently install Acton to ensure clean slate"
run: |
sudo apt-get purge -qy acton
- name: "Install Acton from APT tip repo"
run: |
wget -q -O - https://apt.acton-lang.io/acton.gpg | sudo apt-key add -
echo "deb http://aptip.acton-lang.io/ tip main" | sudo tee /etc/apt/sources.list.d/acton.list
sudo apt-get update
sudo apt-get install -qy acton
acton version
- name: "Run perf tests and record"
run: |
acton version
cd test/stdlib_tests
acton test perf --record
cd ../perf
acton test perf --record
- name: "Download .deb files"
uses: actions/download-artifact@v8
with:
name: acton-debs-amd64
- name: "Install acton from .deb"
run: |
sudo dpkg -i ./deb/acton_*.deb
acton version
- name: "Run perf tests to compare"
run: |
cd test/stdlib_tests
rm -rf out
acton test perf
cd ../perf
rm -rf out
acton test perf
test-app-sorespo:
strategy:
fail-fast: false
matrix:
arch: [amd64, arm64]
needs: build-debs
uses: "./.github/workflows/test-app.yml"
with:
repo_url: "orchestron-orchestrator/sorespo"
arch: ${{ matrix.arch }}
test-app-orchestron:
needs: build-debs
uses: "./.github/workflows/test-app.yml"
with:
repo_url: "orchestron-orchestrator/orchestron"
test-app-netcli:
needs: build-debs
uses: "./.github/workflows/test-app.yml"
with:
repo_url: "orchestron-orchestrator/netcli"
test-app-netclics:
needs: build-debs
uses: "./.github/workflows/test-app.yml"
with:
repo_url: "orchestron-orchestrator/netclics"
test-app-snappy:
needs: build-debs
uses: "./.github/workflows/test-app.yml"
with:
repo_url: "actonlang/acton-snappy"
test-app-yang:
needs: build-debs
uses: "./.github/workflows/test-app.yml"
with:
repo_url: "orchestron-orchestrator/acton-yang"
test-app-actmf:
needs: build-debs
uses: "./.github/workflows/test-app.yml"
with:
repo_url: "orchestron-orchestrator/actmf"
test-app-ncurl:
needs: build-debs
uses: "./.github/workflows/test-app.yml"
with:
repo_url: "orchestron-orchestrator/ncurl"
test-app-gnmi:
needs: build-debs
uses: "./.github/workflows/test-app.yml"
with:
repo_url: "orchestron-orchestrator/acton-gnmi"
test-app-actxcrypt:
needs: build-debs
uses: "./.github/workflows/test-app.yml"
with:
repo_url: "orchestron-orchestrator/actxcrypt"
test-app-orchino:
needs: build-debs
uses: "./.github/workflows/test-app.yml"
with:
repo_url: "orchestron-orchestrator/orchino"
test-app-lmdb:
needs: build-debs
uses: "./.github/workflows/test-app.yml"
with:
repo_url: "orchestron-orchestrator/acton-lmdb"
test-app-zlib:
needs: build-debs
uses: "./.github/workflows/test-app.yml"
with:
repo_url: "actonlang/acton-zlib"
test-app-http2:
needs: build-debs
uses: "./.github/workflows/test-app.yml"
with:
repo_url: "actonlang/acton-http2"
build-container-image:
needs: [test-macos, test-linux, build-debs]
runs-on: ubuntu-latest
permissions:
contents: read
packages: write
steps:
- name: "Check out repository code"
uses: actions/checkout@v6
- name: "Download deb artifacts"
uses: actions/download-artifact@v8
with:
pattern: acton-debs-*
merge-multiple: true
- name: "Prepare debs for container build"
run: |
set -euo pipefail
deb_amd64=$(ls deb/acton_*amd64.deb | head -n1)
deb_arm64=$(ls deb/acton_*arm64.deb | head -n1)
echo "Using debs: $deb_amd64 and $deb_arm64"
version=$(basename "$deb_amd64")
version=${version#acton_}
version=${version%_amd64.deb}
echo "AMD64_DEB=$deb_amd64" >> "$GITHUB_ENV"
echo "ARM64_DEB=$deb_arm64" >> "$GITHUB_ENV"
echo "VERSION_FROM_DEB=$version" >> "$GITHUB_ENV"
- name: "Determine container tag & push intent"
id: container_meta
env:
GHCR_OWNER: ${{ github.repository_owner }}
run: |
ref="${GITHUB_REF}"
owner="${GHCR_OWNER:-actonlang}"
version="${VERSION_FROM_DEB:-unknown}"
push=false
alias_tag=""
if [[ "$ref" == refs/tags/v* ]]; then
push=true
elif [[ "$ref" == refs/heads/main ]]; then
push=true
alias_tag="tip"
fi
echo "version_tag=$version" >> "$GITHUB_OUTPUT"
echo "push=$push" >> "$GITHUB_OUTPUT"
echo "owner=$owner" >> "$GITHUB_OUTPUT"
echo "alias_tag=$alias_tag" >> "$GITHUB_OUTPUT"
- name: "Set up QEMU"
uses: docker/setup-qemu-action@v4
- name: "Set up Docker Buildx"
uses: docker/setup-buildx-action@v4
- name: "Log in to GHCR"
if: steps.container_meta.outputs.push == 'true'
uses: docker/login-action@v4
with:
registry: ghcr.io
username: ${{ github.actor }}
password: ${{ secrets.GITHUB_TOKEN }}
- name: "Build container image"
run: |
set -euo pipefail
version="${{ steps.container_meta.outputs.version_tag }}"
owner="${{ steps.container_meta.outputs.owner }}"
alias_tag="${{ steps.container_meta.outputs.alias_tag }}"
image_base="ghcr.io/${owner}/acton"
image_version="${image_base}:${version}"
image_latest="${image_base}:latest"
push="${{ steps.container_meta.outputs.push }}"
if [[ "$push" == "true" ]]; then
platforms="linux/amd64,linux/arm64"
else
platforms="linux/amd64"
fi
build_flags=(--file Containerfile.deb --label "org.opencontainers.image.version=${version}" --provenance=false --sbom=false --platform "$platforms")
if [[ "$push" == "true" ]]; then
docker buildx build "${build_flags[@]}" --tag "$image_version" --push .
if [[ -n "$alias_tag" ]]; then
docker buildx imagetools create --tag "${image_base}:${alias_tag}" "$image_version"
fi
if [[ "${{ github.ref }}" == refs/tags/v* ]]; then
docker buildx imagetools create --tag "$image_latest" "$image_version"
fi
else
docker buildx build "${build_flags[@]}" --tag "$image_version" --load .
fi
# If we are on the main branch, we'll create or update a pre-release called
# 'tip' which holds the latest build output from the main branch! We upload
# artifacts twice, first with the version number held in the filename and a
# second time after being renamed to remove the version number in the
# filename, thus providing a stable URL for downloading the tip tar balls.
pre-release-tip:
# Only run on the main branch
if: github.ref == 'refs/heads/main'
runs-on: ubuntu-latest
needs: [test-macos, test-linux, build-debs, build-container-image]
steps:
- name: "Delete current tip release & tag"
uses: dev-drprasad/delete-tag-and-release@v1.1
with:
delete_release: true
tag_name: tip
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
- name: "Check out repository code"
uses: actions/checkout@v6
- name: "Download artifacts for Macos aarch64, built on macos-15"
uses: actions/download-artifact@v8
with:
name: acton-macos-15-aarch64
- name: "Download artifacts for Macos x86_64, built on macos-15"
uses: actions/download-artifact@v8
with:
name: acton-macos-15-x86_64
- name: "Download artifacts for Linux x86_64, built on Debian:11"
uses: actions/download-artifact@v8
with:
name: acton-debian-11-x86_64
- name: "Download artifacts for Linux arm64, built on Ubuntu:24.04"
uses: actions/download-artifact@v8
with:
name: acton-ubuntu-24.04-arm64v8
- name: "Download artifacts for Debian Linux on amd64 (x86_64) & arm64 (aarch64)"
uses: actions/download-artifact@v8
with:
pattern: acton-debs-*
merge-multiple: true
- name: "List downloaded artifacts"
run: |
ls
ls deb
- name: "Workaround for changelog extractor that looks for number versions in headlines, which won't work for 'Unreleased'"
run: sed -i -e 's/^## Unreleased/## [999.9] Unreleased\nThis is an unreleased snapshot built from the main branch. Like a nightly but more up to date./' CHANGELOG.md
- name: "Extract release notes"
id: extract-release-notes
uses: ffurrer2/extract-release-notes@v3
- name: "(re-)create 'tip' release notes and upload artifacts as assets"
uses: ncipollo/release-action@v1
with:
allowUpdates: true
artifacts: "acton*.tar*,deb/*deb"
body: ${{ steps.extract-release-notes.outputs.release_notes }}
draft: false
prerelease: true
name: "tip"
tag: "tip"
token: ${{ secrets.GITHUB_TOKEN }}
replacesArtifacts: true
- name: "Remove version number from macos aarch64 tar ball"
run: mv $(ls acton-macos-aarch64*.tar.xz | tail -n1) acton-macos-aarch64-tip.tar.xz
- name: "Remove version number from macos x86_64 tar ball"
run: mv $(ls acton-macos-x86_64*.tar.xz | tail -n1) acton-macos-x86_64-tip.tar.xz
- name: "Remove version number from linux x86_64 tar ball"
run: mv $(ls acton-linux-x86_64*.tar.xz | tail -n1) acton-linux-x86_64-tip.tar.xz
- name: "Remove version number from linux aarch64 tar ball"
run: mv $(ls acton-linux-aarch64*.tar.xz | tail -n1) acton-linux-aarch64-tip.tar.xz
- name: "Remove version number from debian amd64 package"
run: mv $(ls deb/acton_*amd64.deb | tail -n1) deb/acton_tip_amd64.deb
- name: "Remove version number from debian arm64 package"
run: mv $(ls deb/acton_*arm64.deb | tail -n1) deb/acton_tip_arm64.deb
- name: "List files for debug"
run: |
ls
ls deb
- name: "Upload artifacts without version number for stable links"
uses: ncipollo/release-action@v1
with:
allowUpdates: true
artifacts: "acton*.tar*,deb/acton_*.deb"
body: ${{ steps.extract-release-notes.outputs.release_notes }}
draft: false
prerelease: true
name: "tip"
tag: "tip"
token: ${{ secrets.GITHUB_TOKEN }}
replacesArtifacts: true
# Release job, only run for version tagged releases.
release:
if: startsWith(github.ref, 'refs/tags/v')
runs-on: ubuntu-latest
needs: [test-macos, test-linux, build-debs, build-container-image]
steps:
- name: "Check out repository code"
uses: actions/checkout@v6
- name: "Download artifacts for Macos aarch64, built on macos-15"
uses: actions/download-artifact@v8
with:
name: acton-macos-15-aarch64
- name: "Download artifacts for Macos x86_64, built on macos-15"
uses: actions/download-artifact@v8
with:
name: acton-macos-15-x86_64
- name: "Download artifacts for Linux x86_64, built on Debian:11"
uses: actions/download-artifact@v8
with:
name: acton-debian-11-x86_64
- name: "Download artifacts for Linux arm64, built on Ubuntu:24.04"
uses: actions/download-artifact@v8
with:
name: acton-ubuntu-24.04-arm64v8
- name: "Download artifacts for Debian Linux"
uses: actions/download-artifact@v8
with:
pattern: acton-debs-*
merge-multiple: true
- name: "List downloaded artifacts"
run: ls
- name: "Extract release notes"
id: extract-release-notes
uses: ffurrer2/extract-release-notes@v3
- name: "Create release"
uses: ncipollo/release-action@v1
with:
allowUpdates: true
artifacts: "acton*.tar*,deb/*deb"
body: ${{ steps.extract-release-notes.outputs.release_notes }}
draft: false
token: ${{ secrets.GITHUB_TOKEN }}
replacesArtifacts: true
# Update apt repo
update-apt-repo:
if: startsWith(github.ref, 'refs/tags/v')
runs-on: ubuntu-latest
container:
image: debian:experimental
needs: [test-macos, test-linux, build-debs]
steps:
- name: Install build prerequisites
run: |
apt-get update
apt-get install -qy -t experimental reprepro
apt-get install -qy git gnupg
- name: Import GPG key
id: import_gpg
uses: crazy-max/ghaction-import-gpg@v7
with:
gpg_private_key: ${{ secrets.APT_GPG_PRIVATE_KEY }}
- name: Check out code of apt.acton-lang.io repo
uses: actions/checkout@v6
with:
repository: actonlang/apt.acton-lang.io
path: apt
ssh-key: ${{ secrets.APT_DEPLOY_KEY }}
- name: "Download artifacts for Debian Linux"
uses: actions/download-artifact@v8
with:
path: .
pattern: acton-debs-*
merge-multiple: true
- name: "Get the version"
id: get_version
run: |
echo "version=$(ls ../deb/*amd64.changes | sed -e 's/.*acton_//' -e 's/_amd64.*//')" >> $GITHUB_OUTPUT
- name: "Include new deb in Apt repository"
run: |
cd apt
for changes_file in ../deb/*.changes; do
reprepro include stable "$changes_file"
done
- name: "Push updates to git repository for apt.acton-lang.io"
run: |
cd apt
git config user.name "Apt Bot"
git config user.email apt@acton-lang.org
git add .
git status
git diff
git commit -a -m "Add Acton v${{steps.get_version.outputs.version}}"
git push
# Update apt tip repo
update-apt-tip-repo:
# Only run on the main branch
if: github.ref == 'refs/heads/main'
runs-on: ubuntu-latest
container:
image: debian:experimental
permissions:
contents: write
needs: [test-macos, test-linux, build-debs]
steps:
- name: Install build prerequisites
run: |
apt-get update
apt-get install -qy -t experimental reprepro
apt-get install -qy git gnupg
- name: Check out code of aptip.acton-lang.io repo
uses: actions/checkout@v6
with:
repository: actonlang/aptip.acton-lang.io
path: apt
ssh-key: ${{ secrets.APT_TIP_DEPLOY_KEY }}
- name: "Download artifacts for Debian Linux"
uses: actions/download-artifact@v8
with:
path: .
pattern: acton-debs-*
merge-multiple: true
- name: "Get the version"
id: get_version
run: |
echo "VERSION=$(ls deb/*amd64.changes | sed -e 's/.*acton_//' -e 's/_amd64.*//')" >> $GITHUB_ENV
echo "version=$(ls deb/*amd64.changes | sed -e 's/.*acton_//' -e 's/_amd64.*//')" >> $GITHUB_OUTPUT
- name: "Move .deb files in place"
run: |
cd apt
mv -v ../deb/* deb/
- name: "Configure git"
run: |
cd apt
git config user.name "Apt Bot"
git config user.email apt@acton-lang.org
- name: "Push updates to git repository for aptip.acton-lang.io"
run: |
cd apt
git add deb/*
git status
git commit -a -m "Add Acton tip v${VERSION}"
git push
# Update our homebrew tap
update-homebrew:
if: startsWith(github.ref, 'refs/tags/v')
runs-on: ubuntu-latest
# Depend on all test jobs so we don't update brew repo in case anything fails
needs: [test-macos, test-linux, build-debs]
steps:
- name: "Check out code of main acton repo"
uses: actions/checkout@v6
- name: "Get the version from version.mk"
id: get_version
run: |
cat version.mk
# Set both as environment variable for current job and as output for other steps
VERSION=$(grep -o '[0-9]\+\.[0-9]\+\.[0-9]\+' version.mk)
echo "Found version: $VERSION"
echo "VERSION=$VERSION" >> $GITHUB_ENV
echo "version=$VERSION" >> $GITHUB_OUTPUT
- name: "Download release tarball"
run: wget https://github.com/actonlang/acton/archive/refs/tags/v${VERSION}.tar.gz
- name: "Calculate SHA256 checksum"
run: sha256sum v${VERSION}.tar.gz
- id: shasum
run: |
CHECKSUM=$(sha256sum v${VERSION}.tar.gz | cut -d' ' -f1)
echo "sum=$CHECKSUM" >> $GITHUB_OUTPUT
echo "Checksum: $CHECKSUM"
- name: "Check out code of our brew repo"
uses: actions/checkout@v6
with:
repository: actonlang/homebrew-acton
path: homebrew-acton
- name: "Update formula in homebrew-acton from acton repo"
run: |
cp homebrew/Formula/acton.rb homebrew-acton/Formula/acton.rb
- name: "Update brew formula for acton with new version"
run: |
sed -i -e 's,^ url.*, url "https://github.com/actonlang/acton/archive/refs/tags/v'${VERSION}'.tar.gz",' -e 's/^ sha256.*/ sha256 "'${{ steps.shasum.outputs.sum }}'"/' homebrew-acton/Formula/acton.rb
echo "Updated formula to version ${VERSION} with checksum ${{ steps.shasum.outputs.sum }}"
cat homebrew-acton/Formula/acton.rb | grep -A 1 "^ *url"
- name: "Create Pull Request"
uses: peter-evans/create-pull-request@v8
with:
path: homebrew-acton
token: ${{ secrets.ACTBOT_PAT }}
branch: acton-v${{ env.VERSION }}
title: "acton v${{ env.VERSION }}"
body: |
Automatic update triggered by release on actonlang/acton.
committer: Acton Bot <actbot@acton-lang.org>
commit-message: "acton v${{ env.VERSION }}"
signoff: false
================================================
FILE: .github/workflows/trigger-web-update.yml
================================================
name: Trigger rebuild of Acton Web page
# When there are changes to files under docs/acton-guide on main branch,
# trigger the workflow to rebuild the Acton web page
on:
push:
branches:
- main
paths:
- 'docs/acton-guide/**'
jobs:
trigger_web_rebuild:
runs-on: ubuntu-latest
steps:
- name: "Trigger build of www.acton-lang.org"
uses: benc-uk/workflow-dispatch@v1
with:
repo: actonlang/www.acton-lang.org
token: ${{ secrets.ACTBOT_PAT }}
workflow: main.yml
ref: main
- name: "Trigger build of acton.guide"
uses: benc-uk/workflow-dispatch@v1
with:
repo: actonlang/acton.guide
token: ${{ secrets.ACTBOT_PAT }}
workflow: main.yml
ref: main
================================================
FILE: .github/workflows/update-ask-acton-vector-store.yml
================================================
name: Update Ask Acton vector store
on:
push:
branches:
- main
paths:
- 'docs/acton-guide/**'
workflow_dispatch:
concurrency:
group: ask-acton-vector-store
cancel-in-progress: true
jobs:
update_vector_store:
runs-on: ubuntu-latest
permissions:
contents: read
steps:
- name: Check out Acton
uses: actions/checkout@v6
- name: Check out Ask Acton indexer
uses: actions/checkout@v6
with:
repository: actonlang/ask-acton
path: ask-acton
token: ${{ secrets.ACTBOT_PAT }}
- name: Set up Node.js
uses: actions/setup-node@v6
with:
node-version: '22'
cache: npm
cache-dependency-path: ask-acton/package-lock.json
- name: Install Ask Acton dependencies
working-directory: ask-acton
run: npm ci
- name: Update vector store
working-directory: ask-acton
env:
OPENAI_API_KEY: ${{ secrets.ASK_ACTON_OPENAI_API_KEY || secrets.OPENAI_API_KEY }}
OPENAI_VECTOR_STORE_ID: ${{ secrets.ASK_ACTON_VECTOR_STORE_ID || secrets.OPENAI_VECTOR_STORE_ID }}
DOCS_DIR: ${{ github.workspace }}/docs/acton-guide/src
DOCS_REVISION: ${{ github.sha }}
INDEX_REPLACE_SOURCE: 'true'
run: npm run index:docs
================================================
FILE: .github/workflows/webex-notifications.yml
================================================
name: Webex Notifications
on:
pull_request:
types: [closed]
branches: [main]
jobs:
notify-webex:
runs-on: ubuntu-latest
if: github.event.pull_request.merged == true
steps:
- name: Prepare notification message
id: message
env:
PR_NUMBER: ${{ github.event.pull_request.number }}
PR_URL: ${{ github.event.pull_request.html_url }}
PR_TITLE: ${{ github.event.pull_request.title }}
PR_BODY: ${{ github.event.pull_request.body }}
run: |
MESSAGE="### PR [#${PR_NUMBER}](${PR_URL}) merged: ${PR_TITLE}"
if [ -n "$PR_BODY" ]; then
#MESSAGE="${MESSAGE}"$'\n'$'\n''```'
# TODO: does this contain an extra newline?
MESSAGE="${MESSAGE}"$'\n'"${PR_BODY}"
#MESSAGE="${MESSAGE}"$'\n''```'
fi
echo "message<<EOF" >> $GITHUB_OUTPUT
echo "$MESSAGE" >> $GITHUB_OUTPUT
echo "EOF" >> $GITHUB_OUTPUT
- name: Send Webex notification
env:
WEBEX_TOKEN: ${{ secrets.WEBEX_TOKEN }}
WEBEX_ROOM_ID: ${{ secrets.WEBEX_ROOM_ID }}
run: |
set -euo pipefail
# Write the prepared message to a file verbatim to avoid shell quoting issues
cat > message.txt <<'__WEBEX_MSG__'
${{ steps.message.outputs.message }}
__WEBEX_MSG__
# Build JSON payload safely; jq will handle JSON escaping
JSON_PAYLOAD=$(jq -n \
--arg roomId "$WEBEX_ROOM_ID" \
--rawfile markdown message.txt \
'{roomId: $roomId, markdown: $markdown}')
# Send message to Webex room using direct API call
RESPONSE=$(curl -sS -X POST "https://webexapis.com/v1/messages" \
-H "Authorization: Bearer $WEBEX_TOKEN" \
-H "Content-Type: application/json" \
-d "$JSON_PAYLOAD" \
-w "\n%{http_code}")
HTTP_CODE=$(echo "$RESPONSE" | tail -n1)
BODY=$(echo "$RESPONSE" | head -n-1)
if [ "$HTTP_CODE" -ne 200 ]; then
echo "::error::Failed to send Webex notification. HTTP code: $HTTP_CODE"
echo "Response: $BODY"
exit 1
else
echo "✅ Webex notification sent successfully!"
fi
================================================
FILE: .gitignore
================================================
**/.ccls-cache/*
**/.zig-cache/*
*~
*.o
*.a
**/.DS_Store
**/.stack-work
**/*.dSYM
**/*.hi
**/*.o
**/a.out
**/build.zig*
**/core
**/build-cache
**/zig-cache
**/.acton.compile.lock
**/.acton.lock
**/.build/
**/*.swp
**/*.ty
backend/actondb
backend/failure_detector/db_messages_test
backend/test/actor_ring_tests_local
backend/test/actor_ring_tests_remote
backend/test/db_unit_tests
backend/test/queue_unit_tests
backend/test/skiplist_test
backend/test/test_client
base/build-cache
base/out
builder/builder
builder/build_runner.zig
builder/zig-cache
compiler/package.yaml
compiler/acton/acton.cabal
compiler/acton/package.yaml
compiler/lib/package.yaml
compiler/lsp-server/package.yaml
compiler/lsp-server/lsp-server-acton.cabal
test/package.yaml
debian/.debhelper
debian/acton/
debian/acton.substvars
debian/debhelper-build-stamp
debian/changelog
debian/files
deps/*
deps-download
dist/*
builder/deps/*
examples/*
!examples/*.*
!examples/*/
examples/**
!examples/**/*.*
!examples/**/*/
test/*
!test/*.*
test/*.log
!test/*/
test/**
!test/Makefile
!test/**/*.*
test/**/*.log
!test/**/*/
!test/**/snapshots/
!test/**/snapshots/**/
!test/**/snapshots/**/*
test/**/snapshots/output/**
snapshots/output/**
# tests organized as acton projects; ignore all but source
test/*/*/out/**
compiler/acton/test/project/*/out
================================================
FILE: .gitmodules
================================================
[submodule "test/Unity"]
path = test/Unity
url = https://github.com/ThrowTheSwitch/Unity.git
================================================
FILE: AGENTS.md
================================================
Acton compiler notes:
- `acton build --no-threads` controls whether the produced Acton binary uses
threads in Acton RTS. It does not disable threads in the Acton compiler
process itself, so compilation still happens concurrently. This flag is only
to be used for compatibility with platforms that do no have thread support,
for example cross-compiling for Windows, we build without threads.
================================================
FILE: CHANGELOG.md
================================================
# Changelog
## Unreleased
### Compiler & Build
- Add concurrent top-level type checking for total statements, allowing the
compiler to check independent top-level definitions in parallel while keeping
source-order semantics for non-total statements. [#2773, #2782]
- Verbose and timing builds now report inferred signatures for non-total
statements, making it easier to add explicit signatures and unlock more
concurrent checking.
- Type errors from independent total statements are collected into multiple
diagnostics instead of stopping at the first failing statement.
- Use a fixed worker pool with bounded lookahead, improving memory behavior
and performance for modules with many independent top-level definitions.
- Parse modules in parallel by splitting top-level statement chunks across
parser workers, reducing parser latency for large source files while
preserving source-order results. [#2787]
- `--parse-serial` keeps the whole-file parser available for debugging and
fallback comparisons.
- Module-suite validation now uses a set-based duplicate check, avoiding
quadratic validation time in large projects.
- Report parser progress percentages during builds, giving useful feedback for
very large files before type checking starts. [#2784]
- Preserve each module's import context in cached module interfaces, so builds,
`acton sig`, documentation, and completion can reuse cached interfaces without
losing imported class and protocol information. [#2779]
- Speed up compiler environment lookups and scans in large modules by indexing
active names, separating closed imports and finalized top-level names from
live local bindings, and deduplicating reserved names with a hash index while
preserving source-order semantics. [#2789, #2796, #2797]
### Packages & Distribution
- Change x86_64 Linux builds from statically linked GNU libc to dynamically
linked GNU libc while keeping other libraries statically linked. [#2774,
#2781]
- The x86_64 Linux release job and Debian package builds run on Debian 11 to
provide a glibc 2.31 floor.
- Nightly CI still covers Debian 11, 12, and 13 on x86_64.
- CI now validates the dynamic library set and maximum required GLIBC version
for `acton`, `lsp-server-acton`, and `actondb`.
- Vendor the `diagnose` compiler diagnostic library from upstream after
`diagnose` removed its stale `text <=2.0` dependency, so compiler builds can
use the resolver's `text` package instead of pinning `text-2.0` just for
diagnostics. [#2783]
### Documentation
- Document when and how to use the Acton container image, including
copy-pastable Docker commands for checking the compiler version and building
the current project. [#2767]
### Testing & CI
- Add a dedicated type-checking benchmark driver that reports parse,
environment, kind-checking, and type-checking timings, with optional RTS
allocation and GC statistics for compiler performance work. [#2794]
- Add a generated class-heavy type-checking fixture to exercise concurrent
type-checking scheduler performance on large recursive class structures. [#2777]
## [0.27.0] - 2026-05-08
### Added
- Add precise content-hash based build output reuse throughout the compiler
pipeline for optimal compilation [#2447, #2497, #2581, #2674]
- Acton now decides whether previous typechecking results, generated build
outputs, and downstream work are still valid from source and dependency
content instead of relying on file modification times
- Cached module interfaces record source hashes, module-level public and
implementation hashes, and per-name source / public / implementation hashes
- Per-name dependency hashes let the compiler track exactly which names a
declaration depends on, so unrelated edits do not force whole modules or
downstream dependents to be rebuilt
- Public type-signature changes rerun front passes for affected downstream
modules; implementation-only changes can refresh implementation hashes and
rerun back passes / code generation without forcing unrelated typechecking
- When hashes match, cached build output is reused directly instead of
reparsing, re-typechecking, or regenerating work that is already fresh
- Add concurrent module compilation across the build graph. [#2524, #2527]
- The compiler schedules modules as soon as their dependencies are ready,
allowing independent parts of a project to typecheck in parallel
- Front passes and back passes are separated, so dependent modules can start
once an interface is available while normalization, C generation, and other
back-end work continue in parallel
- Ready modules are prioritized by critical path so large dependency branches
do not leave available workers idle
- This keeps project builds, watch mode, and LSP feedback responsive while
still producing the same deterministic build outputs
- Add VS Code editor support through the Acton language server. [#2487, #2753]
- The VS Code extension can now show Acton syntax and type errors inline,
using the same parser and typechecker as `acton build`
- Completion suggests attribute names, function and method argument names,
and other relevant source-level names
- Hover shows Acton information for names under the cursor
- Editor state is kept in memory for fast lookups, so completion and
diagnostics stay responsive while typechecking continues
- Add `acton doc` command for generating documentation [#2274, #2284, #2292,
#2293, #2295]
- Supports multiple output formats (text, markdown, HTML)
- Default is to open browser into HTML docs when window environment is
available, in terminal we fall back to colored text output. Use `acton doc
-t` to force text / terminal output.
- Plain `acton doc` will show module index in browser - for terminal output, a
source file must be given, like `acton doc src/foo.act -t`
- Text output is colored for output to TTY (terminal), piping output falls
back to plain ASCII output. Also honors `NO_COLOR` env var
- HTML supports:
- colorized output of types etc
- inter-module links to type definitions
- explanatory tooltips for generic types
- Add optional chaining and forced unwrapping for optional values [#2672, #2726]
- `person?.residence?.name` returns `None` when any step is `None`
- `person!.residence!.name` raises `ValueError` when a required step is
unexpectedly `None`
- Both forms support attribute access and method calls via `?.` / `!.`, plus
indexing and slicing via `?[...]` / `![...]`
- Add `acton sig` to inspect inferred type signatures using the same
project-aware module and dependency resolution as `acton build`. [#2746]
- Useful when an error says `foo.bar` does not have attribute `X`, since
`acton sig foo.bar` resolves names like the compiler does: first as `bar`
in module `foo`, then as module `foo.bar`
- Add docstring support throughout compiler and AST [#2282]
- Parse docstrings in AST declarations [#2269, #2270, #2271, #2565, #2736]
- Unescape docstrings in NameInfo
- Allow module docstrings before imports
- Add short options support for argparse module [#2289]
- Add global command-line options support to actonc [#2291]
- Add new Hashable protocol and hash() builtin function [#2255]
- Replace __hash__ method with new composable hashing approach
- Types implement `.hash(self, hasher)` method to update a stateful hasher object
- The hasher accumulates state from multiple fields: `self.x.hash(h); self.y.hash(h)`
- Use the `hash()` function to get hash values: `h = hash(my_object)`
- All built-in types implement Hashable protocol
- Uses fast wyhash algorithm via Zig implementation
- Parser / Syntax errors are now prettier [#2306, #2307, #2309]
- Replace basic error rendering with elegant unicode style using Diagnose library
- Better structured error reporting using Megaparsec's ADT typed error system
- Improve error messages for type variable name violations
- Clear hints explaining that single uppercase letters are reserved for type variables
- Show cases possibilities of new parser error diagnostics
- Plain ASCII example (in terminal is even prettier):
```
[error Parse error]: Invalid name (reserved for type variables)
+--> test/syntaxerrors/err41.act@1:7-1:8
|
1 | class Z(value):
: ^
: `- invalid name 'Z'
:
| Hint: Single upper case character (optionally followed by digits) are reserved for type variables. Use a longer name.
-----+
```
- Improve string interpolation parsing [#2321]
- String parsing has been rewritten from scratch
- String interpolation now works by default in all string literals (no f-prefix required)
- Both `"hello {name}"` and `f"hello {name}"` support interpolation
- The change to interpolate normal strings is backwards **incompatible**, any
strings containing curly braces now need to be escaped or be converted to
raw strings, i.e. "{" -> "{{" or r"{"
- Backwards compatibility for classic `%` operator style is currently
maintained, i.e. NO interpolation is performed for `s = "hello %s, here is
{}" % name`, so curly braces are treated literaly
- NOTE: %-operator style formatting will be deprecated in the future
- Parser support nested interpolation strings (thought the necessary rewrites
- Properly handle escape sequences in interpolated strings
- Support complex expressions in interpolations including slices (`{arr[1:3]}`)
- Better error messages for malformed format specifications and many other cases
```
ERROR: [error Syntax error]: Empty format specifier after ':'
╭──▶ test@1:27-1:27
│
1 │ f"Unbalanced format {name:}:10}"
•
• ╰╸ Empty format specifier after ':'
─────╯
```
- Let `repr()` and `type()` accept optional values [#2373]
- `repr(None)` returns `"None"` and `type(None)` returns `"None"`
- More convenient than needing wrapper functions for optional values
- Add webex PR merge notification [#2372]
- Recognize projects by `Build.act` & `build.act.json` [#2358]
- Accept `Build.act` (new ideal), `build.act.json` (common), or `Acton.toml` (existing)
- Check for `src/` directory presence for robustness
- Allow any expression after `after` [#2342]
- Previously limited to local functions, now supports method calls, actor methods, etc.
- `after 1.5: obj.method()` and `after 0.1: remote_actor.action()` are now valid
- Add `utils/update-changelog.sh` script to update this file (`CHANGELOG.md`) using Claude - it's a good prompt!
- Allow logging of optional values [#2382]
- Change logging data parameter type from `dict[str, value]` to `dict[str, ?value]`
- Enables structured logging with None values like `{"user": None, "count": 42}`
- Add `acton build FILE` for file-oriented builds through the main CLI. [#2471,
#2592]
- Add `acton build --watch` for fast edit/build feedback loops. [#2571]
- Watch mode performs an initial project build and then keeps running,
rebuilding automatically when source files change
- Ordinary `.act` file edits use the incremental compiler scheduler, so
unchanged modules, dependencies, and back-end work can be reused instead of
rebuilding the whole project
- Adding or removing source files, or changing `Build.act`, triggers project
rediscovery so the build graph stays aligned with the project layout and
dependency configuration
- New edits supersede older in-flight work, which keeps the compiler
responsive while a user is actively typing
- Single-file watch is also supported with `acton build FILE --watch` or
`acton FILE --watch`
- `acton test --watch` uses the same machinery and reruns affected test
modules after successful rebuilds
- Add `acton spec` commands for inspecting and updating `Build.act` as JSON.
[#2534]
- Expand `acton pkg` package management [#2534, #2554, #2586, #2596]
- `acton pkg update` downloads the package index
- `acton pkg search` searches the local package index
- `acton pkg add` can add packages by package name, archive URL, or GitHub
repository URL
- `acton pkg upgrade` updates dependencies with stored repository metadata
- `acton zig-pkg add/remove` manages Zig package dependencies in `Build.act`
- Add project fingerprints to `Build.act` [#2634, #2681]
- Fingerprints identify project lineage and are validated against the project
name
- This makes accidental project renames and dependency identity conflicts
easier to detect
- Add local dependency overrides with `--dep NAME=PATH`. [#2555]
- Add release mode aliases [#2708, #2761]
- `--release` and `--optimize=release` select `ReleaseFast`
- `--release=safe`, `--release=small`, and `--release=fast` select
`ReleaseSafe`, `ReleaseSmall`, and `ReleaseFast`
- Add `--jobs`, `--tty`, `--no-progress`, and `--timing` controls to the main
`acton` CLI. [#2478, #2526, #2628]
- Add `--parse-ast` for compiler debugging. [#2541]
- Add JSON output for `acton test` and `acton test list`. [#2598]
- Add a content-hash based result cache for `acton test`. [#2651]
- Test results can be reused when the tested module, its dependencies, and
expected snapshot data have not changed
- This makes repeated test runs much faster while still invalidating cached
results when relevant source or dependency content changes
- Use `acton test --no-cache` to bypass the cache and force selected tests to
rerun
- Add `acton test --show-log` to always print captured test logs. [#2408]
- Add `acton test --accept` as an alias for accepting snapshot / golden
output. [#2584]
- Add `acton test stress` mode for repeated concurrent test execution.
[#2683, #2691, #2692, #2694]
- `--stress-workers` controls the worker count
- Stress output shows mixed outcomes and phase coverage while running
- Add test capability tags with `testing.require()` and `acton test --tag`.
[#2655]
- Add `--min-time`, `--max-time`, `--min-iter`, and `--max-iter` controls for
test runs. [#2467, #2408]
- Add `u1`, `u8`, `i8`, and builtin `i64` support. [#2532, #2519]
- Add `list.count()` method. [#2521]
- Add JSON encoding / decoding for list values at the document root. [#2508]
- Add `xml.Node.encode(pretty=True)` for pretty XML output. [#2512]
- Add URI `quote()` and `unquote()` helpers. [#2719]
- Add HTTPS server and TLS listener support. [#2576]
- Add an Acton LLDB plugin for debugging Acton programs. [#2520]
- Adds `acton bt`, `acton locals`, `acton demangle`, and `acton break`
commands inside LLDB
- Shows filtered, Acton-demangled backtraces with argument values instead of
forcing users to read raw generated C symbol names
- Prints locals with Acton names and value summaries, including strings,
boxed values, objects, actors, classes, and generic value slots
- Supports Acton source breakpoints like `acton break src/main.act:42`
- Add container image builds for Acton Debian packages. [#1404]
- Add `PROFILE` build option to the Makefile. [#2664]
- `re.match()` now accepts an optional `start_pos` to begin scanning at an
offset. [#2569]
### Changed
- Move total build graph construction, dependency builds, and generated
build.zig / build.zig.zon dependency wiring into the compiler. [#2550,
#2551]
- Use f-strings throughout standard library [#2297, #2290]
- Improve process environment handling [#2298]
- Inherit PATH when custom environment is provided
- Enhance ecosystem lift process with additional documentation [#2272, #2288]
- Extend QuickType with effect output for better comprehension translation [#2267]
- Improve acton.rts.sleep platform coverage [#2303]
- Switch to use new hash() function instead of __hash__ [#2255]
- Remove __hash__ special method in favor of hash() builtin [#2304]
- Rename `docs/acton-by-example` to `docs/acton-guide` [#2313]
- Adopt Zig optimization levels in Acton [#2362]
- Replace `--dev` flag with `--optimize` accepting: Debug, ReleaseSafe, ReleaseSmall, ReleaseFast
- Change default from ReleaseFast to Debug (matching Zig's default)
- `--dev` maps to Debug for backward compatibility, new `--release` maps to ReleaseFast
- Simplify command-line parser structure [#2367]
- Remove deprecated `--dev` option [#2366]
- Revamp `actonc` debug / verbose mode [#2354]
- Avoid writing `.ty` files in Types.reconstruct [#2357]
- Remove unused sysLib & projLib fields from compiler Paths [#2385]
- Cleanup remnants from pre-Zig build system migration
- Simplify Webex PR merge notification & handle escapes [#2376, #2384, #2507]
- Improve message formatting and environment variable handling
- Retire the Acton-written CLI and make the Haskell compiler package provide
the `acton` executable directly. [#2607]
- `acton`, package management, testing, LSP, and compiler scheduling now use
shared compiler code
- The old `actonc` implementation has been renamed to the `acton` compiler
package
- Require `Build.act` for projects and require `name` and `fingerprint` in
root project build files. [#2643, #2644]
- Stabilize public interface hashes, include qualified free names in name
hashing, and preserve full source locations in cached interfaces. [#2578,
#2747, #2752]
- Validate cached `.ty` files with source metadata and treat version, compiler,
and dependency mismatches as recoverable stale cache entries. [#2440, #2717,
#2718]
- Defer full parsing until after project discovery. [#2742]
- Pass explicit module selections into generated Zig builds so dependency builds
only build the modules selected by the compiler. [#2666]
- Use canonical dependency roots in generated `build.zig.zon` files and isolate
transitive Zig dependency names. [#2690, #2696]
- Upgrade the bundled Zig toolchain to 0.15.2. [#2590, #2594]
- Use architecture-based default CPU settings for Zig targets. [#2574]
- Rename `--ignore-compiler` to `--ignore-compiler-version` and make compiler
version / mtime mismatches explicit stale-cache checks. [#2568, #2573,
#2608, #2609]
- Move generated C line directives behind `--dbg-no-lines`. [#2518]
- Enable larger parallel GHC nurseries for compiler builds. [#2522]
- Use HashMaps for imported type environments. [#2517]
- Update the `acton new` project template. [#2589]
- Track build cache growth with periodic checks. [#2475]
- Make snapshot testing use `snapshots/expected` and `snapshots/output`
directories instead of the older golden layout. [#2620]
- Make `acton test --name` regex based. [#2616]
- Store discovered test metadata in `.ty` headers so test discovery can reuse
cached interfaces. [#2636]
- Show cached test failures by default while keeping cached successes hidden.
[#2557]
- Align test progress with build progress, use project-qualified module names
in progress output, and adapt progress width/timer fields to terminal width.
[#2618, #2619, #2628, #2665, #2667, #2682, #2731]
- Use the provided `logging.Handler` in HTTP server actors. [#2698]
- Set empty XML node `text` and `tail` values to `None`. [#2509]
- Make `file.mkdir()` and `file.rmdir()` idempotent. [#2477]
- Use `mkdtemp` semantics for temporary directory creation. [#2693]
- Prebuild one-byte ASCII strings to reduce allocation churn. [#2705]
- Use common dependency builds to avoid redundant rebuilds and guard root-pin
warnings behind `--quiet`. [#2649, #2653]
### Removed
- Remove numpy support from the compiler, parser, stdlib, and tests. [#2413]
- Remove the old explicit stub compilation mode. [#2414]
- Remove the old Acton-written `acton.act` CLI implementation after moving CLI
functionality into the compiler package. [#2607]
### Fixed
- Fix string 'in' operator for substrings found at position 0 [#2280]
- Fix unintended dependency on complete scope when scanning __init__ for attributes [#2285]
- Ensure lambda-bound variables are in scope when comprehensions are translated [#2267]
- Default print diff for testing.assertEqual failure [#2260]
- Fix VERSION substitution in Homebrew PR creation [#2266]
- Fix escaped braces in strings at position 0 [#2370]
- Escaped braces `{{` and `}}` at start of strings were incorrectly parsed as interpolation
- Now correctly converts `"{{a}}"` to `"{a}"` and handles mixed cases like `"{{hello}} {world}"`
- Fix actor constructor alias resolution [#2365]
- Aliased actors from imports (`from worker import Worker`) now correctly generate module-prefixed constructors
- Fixes issues with builtin actors like `StringDecoder` and explicit aliased imports
- Fix `.endswith()` for strings shorter than needle [#2348]
- Prevent out-of-bounds memory access when haystack is shorter than needle
- Fix `acton version` command structure [#2363]
- Avoid superfluous rebuilds for actonc [#2349]
- Replace `$FORMAT` macro with C function [#2327]
- Fix "2320" error [#2323]
- Fix Hashable protocol implementation [#2255]
- Correct zig bytes definition
- Fix issues with bytes containing NUL character
- Fix solver handling of generic tuples, top-level constraint solving,
skolemized type variables, scoped constraints, optional bounds, and coerced
index targets. [#2319, #2332, #2339, #2438, #2564, #2570, #2587, #2603,
#2624, #2661, #2675]
- Accept four or five quotes at the end of triple-quoted strings. [#2388]
- Improve `str.__repr__()` to escape braces correctly and handle quoted
strings. [#2386]
- Fix unclosed string parser diagnostics. [#2486]
- Escape generated C identifiers that became keywords in C23. [#2480]
- Fix Unicode handling in regular expressions. [#2540, #2553]
- Fix parsing, inference, and code generation for negative integer literals,
including the most negative `i64` value. [#2492, #2543]
- Infer `bigint` for integer literals outside the `i64` range. [#2519]
- Fix `argparse` defaults for list arguments and preserve rest arguments after
`--`. [#2473, #2580]
- Fix boolean singleton use and `None` checks in arbitrary boolean contexts.
[#2485, #2491]
- Fix `bytes.startswith()` end-bound checks. [#2410]
- Fix `bytes.split()` and `bytearray.split()` for empty separator edge cases.
[#2453]
- Fix tuple printing when tuple values contain `None`. [#2430]
- Implement `__repr__()` for exceptions. [#2421]
- Fix printing lists that contain optional elements. [#2613]
- Fix violations of the UTF-8 invariant when creating strings. [#2455]
- Fix UTF-8 character / byte offset handling in string partitioning. [#2676]
- Fix `process.pid()` after the process has exited. [#2405]
- Fix process and build output handling for paths containing spaces. [#2516]
- Fix UTF-8 handling in accepted golden test output. [#2593]
- Fix JSON encoding of fixed-size integer values. [#2530]
- Fix XML parse errors to use `XmlParseError` instead of generic runtime
errors. [#2420]
- Fix XML special character escaping, CDATA decoding, UTF-8 handling, and
prefixed attribute decoding. [#2422, #2433]
- Fix HTTP response callbacks to pass headers and treat header defaults
case-insensitively. [#2448]
- Validate malformed HTTP requests and responses instead of accepting invalid
input or crashing during decode. [#2454, #2457]
- Fix `is not None` lowering and optional narrowing through comprehension head
expressions. [#2412, #2402, #2720]
- Fix sequential flow analysis around `$RAISE`. [#2401]
- Fix `while ... else` handling and reevaluate effectful loop conditions each
iteration. [#2464, #2466]
- Fix `and` / `or` expressions when unboxing is involved. [#2465]
- Fix type casts to unboxable values during code generation. [#2479]
- Fix conversion of dot selections with partially aliased import chains. [#2700]
- Fix term substitution when the substitution range and domain overlap. [#2701]
- Fix lambda lifting and CPS edge cases around converted closure types and
nested control flow. [#2709, #2735, #2737]
- Fix class attribute initialization checks and improve diagnostics for
uninitialized attributes. [#2391]
- Fix class-level and cyclic protocol witness handling. [#2484, #2488, #2556]
- Fix class instance handling of type-parameter witnesses and prevent static
methods from being invoked on instances. [#2623]
- Fix conversion of `Self` in protocol methods after moving protocol conversion
before constraint solving. [#2632]
- Fix optional equality and optional-chain type inference edge cases. [#2716,
#2672, #2726]
- Fix private imported names leaking through interfaces. [#2567, #2752]
- Fix actor `self` checks and discovered actor test wrappers. [#2514, #2535]
- Fix malformed module top-level statements by restricting modules to
declarations, imports, and assignments. [#2728]
- Fix generated name collisions by prefixing generated names with the top-level
name. [#2729]
- Fix stale transitive dependencies after import renames. [#2727]
- Fix transitive imports for cached modules. [#2677]
- Fix missing dependency name hashes by treating them as stale cache entries.
[#2637]
- Fix dependency cache invalidation when a path from `--syspath` changes.
[#2510]
- Fix dependency override handling for declared dependencies. [#2555]
- Validate local `--dep` paths as Acton project roots. [#2638]
- Rework dependency downloads and honor `http_proxy`. [#2640]
- Fetch transitive remote dependencies reachable through path dependencies
before project discovery. [#2668]
- Fix stale implementation refreshes when an interface hash is missing. [#2674]
- Fix orphaned module artifacts after modules are removed. [#2633]
- Preserve normal and test root stubs and prune orphaned binary executables.
[#2265, #2505, #2538]
- Fix relative / absolute path handling for build files and build.zig.zon
syspath entries. [#2493, #2495]
- Skip Zig builds for dependency projects when only Acton interface artifacts
are needed. [#2496]
- Fix `Build.act` null handling and unused dependency builds. [#2539, #2557]
- Force recompilation when an alternate output directory is selected. [#2513]
- Fix `acton --parse` output. [#2536]
- Fix `acton build` handling after Zig toolchain upgrades. [#2595]
- Improve error handling for compiler back passes. [#2597]
- Fix LSP stdout framing corruption. [#2629]
- Fix RTS message waiting so actors are not missed between waiting states and
message delivery. [#2689]
- Clean up libuv file requests to avoid stale request state. [#2695]
- Work around macOS 26.4 command-line tools breaking Zig and set
`DEVELOPER_DIR=/dev/null` for actondb on macOS. [#2715, #2756]
- Restore the Zig dist target. [#2745]
- Delete an accidental root-level copy of `Types.hs`. [#2739]
### Documentation
- Add ecosystem lift process documentation
- Add Hashable protocol documentation to Acton Guide. [#2310]
- Add actor `self`, collection comprehension, and guide organization updates.
[#2314, #2315, #2316, #2318]
- Add Acton developer guide covering repository layout, build flow, compiler
passes, runtime, and testing internals. [#2566]
- Reshape the Acton Guide around task-oriented language, project, testing, and
stdlib documentation. [#2734, #2740, #2750]
- Document optional chaining and forced unwrapping. [#2722, #2732]
- Document class initialization rules and improved uninitialized attribute
diagnostics. [#2391]
- Document project fingerprints and the `Build.act` project format. [#2634,
#2644]
- Document incremental compilation and content hashing. [#2610]
- Document RTS backtrace debugging arguments. [#2615]
- Explain constraint errors with rendered signatures. [#2751]
- Clarify Acton lock ownership responsibilities. [#2678]
- Update Ask Acton vector store data when the guide changes. [#2748]
### Testing / CI
- Support test discovery of actors [#2337]
- Recognize test actors without needing wrapper functions
- Compiler generates wrappers automatically for discovered test actors
- Remove old test types (sync/async/env test functions)
- Update macOS CI to include macos-15 x86_64/aarch64 and macos-26 arm64, and
drop macos-14 to keep the PR matrix small. [#2511, #2583]
- Test run MUSL executables on Linux [#2355]
- Test http2, netclics, zlib, netcli applications [#2338, #2331, #2324]
- Add self name check for actors [#2317]
- Add more parser / syntax error test cases [#2308]
- Stop testing Debian 10 [#2352]
- Drop Debian 11 from test-linux CI matrix [#2588]
- this means we do not test / support Debian 11 as a OS dist for developing Acton itself
- Debian 11 is still a valid run time target for Acton programs
- run-linux still covers compiling & running Acton programs on Debian 11
- Support multiple files for compiler testing framework [#2363]
- Accumulate environment from modules to support imports
- Add compiler pass golden tests for parse, kind, type, normalize, deactorize,
CPS, lambda lift, boxing, header generation, C generation, and signatures.
[#2548]
- Add incremental rebuild regression tests with stable sanitized hash output.
[#2503, #2506, #2581, #2631]
- Add snapshot testing coverage and cache validation for expected snapshot
metadata. [#2639, #2679]
- Add stress testing fixtures with racy and crashing FFI examples. [#2683]
- Add TLS stdlib tests and an HTTPS server test fixture. [#2572, #2576]
- Add ecosystem and ACTMF application tests. [#2641, #2548]
- Add more ecosystem applications to CI coverage. [#2641]
- Add Linux container image builds from Debian packages. [#1404]
- Build Debian packages on Ubuntu 22.04 and fix stack usage in build-debs.
[#2647, #2652]
- Allow Telemetrify failures while macOS 26 support settles. [#2585]
- Drop the shared Acton cache from CI. [#2605]
- Drop Telemetrify from CI. [#2749]
- Add build.zig generated-file gitignores. [#2656]
- Close golden files after reading them during tests. [#2617]
- Update GitHub Actions dependencies including checkout, cache,
upload/download-artifact, create-pull-request, Docker build actions, and
release-note extraction actions. [#2415, #2429, #2498, #2499, #2537,
#2544, #2558, #2559, #2560, #2561, #2669, #2670, #2684, #2685, #2686,
#2687, #2591, #2754, #2755]
## [0.26.0] - 2025-06-02
### Added
- Add list, set, and dict comprehensions [#2258]
- Add CLAUDE.md files for AI assistant guidance [#2262]
- Component-specific development guides
- Code style guidelines and best practices
- Add Claude PR Assistant GitHub Actions workflow [#2261]
### Changed
- Expand numpy test suite [#2259]
- Update install docs to remove architecture restrictions for APT repository [#2253]
### Fixed
- Fix cosmetic race condition in actor waiting queue operations [#2254]
- Ensure atomic setting of waitsfor link when entering waiting state
- Fix handling of NotImplemented extension annotations [#2256]
- Keep annotations until CodeGen for proper constructor generation
### Documentation
- Document changelog update process before releases
- Remove arch=amd64 restriction from APT repository documentation
## [0.25.0] - 2025-04-23
### Added
- Acton Vim plugin for syntax highlighting & indent, see
https://github.com/actonlang/vim-acton
- Add `crypto.hash.md5` module for MD5 hashing
- supports incremental updates and one-shot
- Add `bytes.from_hex()` & `bytes.hex()` for hex encoding/decoding of bytes
- Add `.str_ms()` to `time.Duration`
- Add `max_def` and `min_def` functions that require a default argument
- Unlike max() & min(), these functions require a default value that is
returned when the input iterable is empty
- `max_def([1, 2, 3], -1)` returns 3
- `max_def([], -1)` returns -1
- Add `re.split()` function to split strings based on regular expressions
- `re.split(" +", "a b c")` returns `["a", "b", "c"]`
- Add support for golden testing in the `testing` module
- Test functions can return a `str` to be compared against stored golden values
- `acton test` will show actual vs expected golden value
- Golden values are stored in `test/golden/MODULE/TEST_NAME`
- Update expected values with `--golden-update`
- Unmangle actor class names in logging
- Add `--no-threads` option to compile single-threaded applications
- Set minimum thread stack size to 8MB to avoid stack overflows
- Add better documentation for integer types in the guide
- Add `__name__` variable containing current module name
- Add `complex.from_real_imag()` function to create complex numbers
- Add support for complex numbers as dictionary keys
- Add proper implementation of the Logical protocol for integers
- Add URI parsing module for handling HTTP URLs and other URIs
- Add `--list-imports` option to actonc to show imported modules
- Add a ConsoleSink to the logging module
- Capture log messages in tests for easier troubleshooting
- Add diff module for comparing strings
- Support for unified diff format with customizable context headers and colors
- Add GitHub Action to create new releases automatically
- Add support for ALPN (Application-Layer Protocol Negotiation) in TLS
### Changed
- Dict & Mapping methods `get` and `pop` now return `None` when key is not
found, instead of throwing KeyError
- Use new `get_def` & `pop_def` for explicit default values
- Automatic backtrace printing on crashes disabled on non-Linux platforms
- LLDB on MacOS often hangs, so automatic backtrace printing is disabled
- Make module paths in type error messages clickable for easier navigation
- Improve `RunProcess` handling to properly await EOF for stdout/stderr
- Disable garbage collection during package upgrade operations to improve performance
- Silence build lock messages for dependency builds to reduce output noise
- Use development mode (`--dev`) to build dependencies in test command
- Don't store protocol witnesses in class attributes, push further into methods instead
- Upgrade tlsuv library to v0.33.4 for improved TLS support
- Enhance package dependency handling with support for transitive dependencies
- Use a global dependencies directory in `~/.cache` for better dependency management
- Improve testing output with deduplication of stdout/stderr messages
- Colorize error messages for better readability
- Reintroduce `--tempdir` option to actonc for manual control of temporary files
- Allow integers to overflow for fixed-size integer types (i16, i32, i64, etc.)
- Use diff for golden testing when outputs don't match
- Rename common.mk to version.mk to better reflect its purpose
- Make del operator idempotent for lists and dictionaries
### Fixed
- Fix type conversion between `u16` and `int`
- Fix XML default namespace parsing
- Fix error handling in process actor
- Process signals are now ignored if process has exited
- Better error handling around stdin/stdout/stderr operations
- Fix volatile variables in try-except blocks to avoid compiler optimization
issues impacting control flow
- Fix string format in `time.DateTime`'s RFC1123 format (month was off by one)
- Improve error messages with better source location information
- Added location details for "Missing constraint" errors
- Added location details for "missing tuple component" errors
- Better error reporting when class method's first parameter doesn't match Self type
- Fix dictionary iteration in relation context
- Fix constructor functions for bounded integer types
- Fix CPS transformation for nested lambdas with preprocessing requirements
- Fix handling of main project local dependency overrides
- Fix `zip()` function implementation
- Fix left shift operator (`<<`) for integers
- Fix XML encoding to properly handle UTF-8
- Fix TCP connection close to properly mark socket as invalid
- Fix hash function to avoid signed overflow undefined behavior
- Fix depth subtyping for builtin collections (list, dict, set)
- Fix discovery of root actor based on name
- Fix `acton test --name` to correctly filter tests by name
- Fix string allocation in `B_str` to properly account for byte length
- Fix package upgrade correctness
- Fix handling of XML comments during parsing
- Fix main project dependencies in build.zig.zon
- Fix polarity improvement handling in type solver
- Fix exception handling in iterate-relation context
- Fix `free()` behavior (now a no-op in GC environment)
- Fix race condition in actor waiting queue operations
- Optimize f-string parsing for better performance
### Testing / CI
- Add macos-aarch64 tip release build
- Stop testing on Ubuntu 18.04
- Install gdb in test-app environment for better crash analysis
- Separate caches for Acton build and Stack/GHC in CI to avoid cache thrashing
- Add caching for Linux ARM64 builds to improve CI speed
- Ensure uniqueness of test artifact names to prevent collisions
- Add support for Linux on ARM64 (aarch64) in CI
- Add test of respnet (a real-world Acton application) to CI
- Add testing on Ubuntu 24.04 for ARM64
- Use artifact upload/download v4 for better performance
- Add tests for all compiler passes
- Await cache cleaning to avoid race conditions
## [0.24.1] (2024-11-09)
## Added
- It is now possible to compare actors with `if a is b`
- This is a stop gap measure.
- Equality comparison requires the `Eq` protocol and this awaits the planned
actor / class unification work
## Changed
- Change `TCPListenConnection` callback `on_error(c, error: str)` to
`on_listen(c, error: ?str)`. Previously, the `on_error()` callback was called
if there was an error establishing the listening connection. It is now also
called in the positive case, when we have successfully established the
listening connection. If the `error` argument is `None`, all went well whereas
if it is set, there was an error.
## Fixed
- Dependencies are now idempotently fetched, i.e. if we first look if we already
have the configured hash locally and use that. We only fetch it if we don't
have a dependency locally.
- Previously, `acton build` would effectively require an Internet connection,
which is now fixed. Like now, you can do `acton fetch` in a repo to fetch
all dependencies locally and from there on you can work in "airplane mode".
- Dependency hash mismatch is now correctly checked and treated as an error.
### Testing / CI / Build
- TCP tests have been rewritten to use the new `TCPListenConnection` `on_listen`
callback to properly sequence the test so we first establish the server and
then start the client. This removes a racy condition which lead to flaky test
failures.
- Stopped testing on MacOS 12, which is EoL.
## [0.24.0] (2024-11-05)
Acton now supports package dependencies and has a package manager to work with
these, fetching and building them. There are new docs at https://acton.guide
It's now possible to write Acton low level code in Zig, in addition to C.
## Added
- New docs: https://acton.guide
- Starting point was the Acton-by-Example and it's been improved from there
with new content and updates of existing pages
- New top level structure making it easier to navigate
- Includes a guide on how to integrate a C library
- Package management!
- Acton now supports adding dependencies on other packages, either in a local
path or to be downloaded from the Internet.
- New commands, `acton pkg add` etc to manage dependencies, see
https://acton.guide for more
- This largely relies on the Zig package manager and the Zig build system
- It is also possible to add a Zig package dependency in an Acton project in
order to enable the integration with Zig / C / C++ libraries
- Lots of improvements around the build system
- Upgrade to Zig v0.13
- Avoid anonymousDependency which is deprecated in newer Zig versions
- Materialize build.zig on disk, to allow customization, like adding
dependencies
- Send deps as zig CLI arguments instead of hacking builder imports
- Remove old extra headers, now included in Zig 0.13
- Add `any()` and `all()` - does what it sounds like
- These were previously removed due to a bug but are now brought back
- `json.encode()` now has a `pretty` option to enable pretty printing
- `file.ReadFile()` & `file.WriteFile()` now support taking an advisory lock on
Linux and MacOS
- `acton` now takes a project lock before compiling to avoid races
- Revamped zig build caching, separating the local and global cache
- Only the local one is automatically periodically cleaned
- Add support for writing Acton modules in Zig
- It is now possible to write functions in Zig, thus making the entire Zig
ecosystem potentially reachable with ease
- Add new `base64` module to stdlib
- It is built on the Zig stdlib `base64` functions
- Allow naming overlap in hierarchical modules
- It is now possible to have a module `foo` (src/foo.act) and a `foo.bar`
(src/foo/bar.act), which would previously conflict and yield a compilation
error.
- Improved source location error messages
- Upgraded to Haskell GHC 9.6.6
## Changed
- Add `remote_close` callback to TCPConnection / TCPListenConnection &
TLSconnection
- Use `OSError` instead of `RuntimeError` for general exceptions in the `file`
module functions and classes
- `argparse` `--help` now shows help for the most specific cmd
- Remove worked thread CPU affinity to get compile speedup
- This is primarily as a workaround for slow Zig builds. For `acton build` we
run the acton compiler `actonc` and eventually `zig build`. Zig gets the
number of parallel worker threads to run by inspecting its affinity. When
started by Acton, it inherits the affinity of the worker thread that started
it.
- CPU affinity is probably a win for server workloads, so this is a
regression, but for desktop apps, it likely workb setter not pinning to CPU
cores
## Fixed
- Fixed scope extension to handle accessing variables in else defined in try
- Fixed CPS'ed __init__ so we can correctly instantiate actors in class init
- Fixed passing function with mut effect to actor
- The actor seal leak detection would incorrectly trigger. We need a better
detector, until then the check is removed.
- Fix returning fixed size integer
- The recent unboxing code misbehaved in some situations when trying to return
a fixed size integer from a function
- Fix assert(Not)Equal
- Now actually works for None values, would previously only compare the values
if they were not-None
- Fix qualified name checking, so we can properly detect method invocation via
class name even for imported classes
- This was an issue when importing a module and trying to call a @staticmethod
on a class
## Testing / CI / Build
- Stopped building the vendored libraries we ship, they are now shipped as
source and compiled on demand
- Force hermetic build on MacOS
- Avoids pulling in system libraries
- Simplify actondb build
- Add dependabot config for updating GitHub Actions workflows
- Add test on macos-15
- Test other Acton apps in main Acton repo CI
## [0.23.0] (2024-08-13)
## Added
- More unboxing of fixed size integers
- Function local variables are unboxed
- Passing fixed size integers as arguments between functions is also unboxed
- This adds an extra pass to the compiler to handle boxing and unboxing
- For some programs, the code is now pretty much optimal
- For example, the C code generated from `test/perf/src/dct.act` looks
pretty much as one would write it by hand and thus runs at about the
"speed of C". It does 0 mallocs and runs about 20x faster than before
unboxing (depending a bit on computer).
- class and actor attributes are still boxed
- This is likely the most important future work around unboxing since
individual mallocs for class & actor attributes typically account for a
the lion's share of GC pressure
- It is challenging around generics though
- New `Set.update()` method to add items to a set from an iterable, such as a
list or another set
- Added `--module` argument to `acton test` to select module to test
- For example, `acton test --module foo` to only run tests in module foo
- Improved printing of test results for test modules that crashed
- The error is now printed for each individual test in the test module
- Added `list.index(val, start=0, stop: ?int)` to get the first index of an
element in a list. It can be constrained through the start and stop
parameters.
## Changed
- `re.match()` now returns `Match` object where the group is `list[?str]`. It
used to be `list[str]` but it is possible to have groups that do not match on
anything and so `?str` is the correct type. This applies both for named groups
and normal numbered groups.
- For example, consider `foo((123)|bar)` which matches either `foo123` or
`foobar`. The inner `(123)` group is ORed and so it will have no match for
`foobar`, thus we get the result `m.group = ["foobar", "bar", None]`
- `set.pop()` now throws `ValueError` for an empty set
## Fixed
- Fixed tuple type inference
- Tuples with named fields can now be properly type inferred
- `acton test perf` now limits concurrency to 1 to get better results
- Fix `str.strip()` on empty strings, it would previously return `\n` but now
returns an empty string as it should
- Fixes crash in `re.match()` for groups with no matches, which previously
resulted in `SEGFAULT`
- For example, consider `foo((123)|bar)` which matches either `foo123` or
`foobar`. The inner `(123)` group is ORed and so it will have no match for
`foobar`, thus we get the result `m.group = ["foobar", "bar", None]`
- This would previously crash but we now properly check the result values
- Fix str slicing when range is 0 length which would previously `SIGILL`
- For example, for `a = "foobar"` if we would try to access `a[23:]`, there is
no character 23 and so the length of the slice is 0 which would trigger a
`SIGILL` when compiled in `--dev` mode (which comes with lots of extra
UBsan)
- Fix dict corruption issue when deleting items #1805
- `set.pop()` now does not crash for an empty list (it threw NULL before)
- Fix decoding of buffered test output
### Testing / CI
- Added performance test to CI
- This runs on a dedicated computer, a laptop in Kristian's rack at home
- Runs `acton test perf` in `test/perf` which currently only includes the
`dct` program
- Simply add more test programs to the `test/perf` project to have them run
- The testing procedure is as follow:
- The CI test checks out the tests from the feature branch, so it will
always be the latest version of the test itself
- The latest tip release from acton main branch is installed and used to
compile the `test/perf` project
- `acton test perf --record` is used to run the test and record the result,
which will act as the baseline
- The acton release from the local feature branch is then installed (fetched
as artifact from the `build-debs` job)
- `acton test perf` is now run, which will run with the latest version and
compare the results against the baseline
- We do not currently inspect the results to give a pass / fail score,
they're just printed in the CI output for a human to look at
- Natural variance seems to hover around +-5%, which feels OK
- Revamp PR testing to run on small set of platforms and run a nightly scheduled
test job that includes all platforms that were previously in the PR jobs
- This was triggered by the number of platforms reaching a higher number which
in turn has led to more cached data and as the GitHub Actions runner cache
is limited to 10GB, we hit the limit and got churn which meant that there
were always slow jobs. By reducing the number of PR jobs, they can continue
to run cached whereas the nightly jobs can run without a cache.
- Stop CI testing on MacOS 11 as it has been deprecated by Github
- Start CI testing on Ubuntu 24.04
- Stop CI testing on Ubuntu 23.04 and 23.10 as they are EoL
- Temporary fix of building Acton by using our own mirror for the Zig tar ball.
We are using a particular nightly v0.12.0 build that is no longer available
for download from ziglang.org and so we now mirror it ourselves. This affects
both builds in CI and local builds.
- Fix GitHub Actions to run on Ubuntu 18.04
- The artifact download action uses Node.JS to run and as GitHub has imposed
constraints and new defaults, this has been magically updated to use a newer
version of Node.JS than before. The newer Node version is compiled using
glibc 2.28 and that's too new for Ubuntu 18.04, so the end result is that
you basically can't use the common GitHub Actions with Ubuntu 18.04 or
similar older distros. What a weird way to treat your CI users by GitHub!?
Anyhow, we work around this by explicitly enabling the use of the old Node
again.
- Add caching for test-external-projects of C object files & archives
## [0.22.0] (2024-04-14)
Support for Windows and continued improvements for `acton test`! Internally the
biggest change is the removal of link time redirection of malloc, which opens up
for more flexible memory management.
### Added
- Acton programs now run on Windows!
- It is now possible to compile Acton programs for Windows, both x86_64 and
aarch64, although since Acton itself (compiler etc) is not available on
Windows, only cross-compilation from MacOS or Linux is possible.
- Use `acton --target aarch64-windows-gnu examples/helloworld.act` to produce
`examples/helloworld.exe` which can be run on Windows
- Acton applications compiled for Windows are single threaded
- termios related terminal settings, is not supported on Windows
- Acton RTS now supports actor cleanup through GC finalization
- Define a `action def __cleanup__():` action on your actor and it will be run
when the actor is about to be garbage collected
- `acton build` now builds dependencies in `deps/` before building the main
project
- `acton test` now excludes the time spent in GC from test times
- This is probably somewhat approximate and not super accurate, in particular
for tests with very short test durations
- `acton test perf` is now expanded and support all kinds of tests (previously
only unit tests were supported)
- some memory usage is printed alongside timing information
- GC is run explicitly during perf test to get better memory usage stats but
it also slows things down a bit, in particular for very short duration tests
- `acton test perf --record` can save a performance snapshot to disk
- Subsequent invocations of `acton test perf` will back the data from disk and
display a comparison with percentage diff
- AbE: testing documentation is much improved!
- `acton --only-build` performs only the low level build from .C source,
skipping compilation of .act files. This can be used if you want to modify the
C source by hand and still leverage the low level builder to perform the build.
- `file.FS.cwd()` to get current working directory
- `file.join_path()` to join path components
- Link time redirection of malloc & friends is now removed. All malloc calls are
instead explicit, either directly to `GC_MALLOC` or via `acton_malloc` which
is our own malloc function which is runtime reconfigurable. While there is no
usage of malloc directly from our code, it is now possible to do manual
memory management mixed with GC managed memory.
- As before, module constants are placed in the regular heap, so that the GC
does not have to scan it.
- Many string formatting functions have been reshaped since `asprintf` does an
implicit malloc, which we must either free or avoid. As a result, we now
copy less data around, which speeds things up.
- `process.Process` now takes an optional timeout argument to stop the process
- New `process.RunProcess` that waits for a process to exit and then reports to
a callback with the buffered output from stdout / stderr
- This can provide a simpler interface than `process.Process` if you just want
to wait for the process to finish running before starting to parse its
output as you'll get a single invokation and the full output rather than
receive it piecemeal
- Add `.unix_s()` `.unix_ms()` `.unix_us()` `.unix_ns()` to `time.Instant`
- To get a Unix timestamp (seconds since 1970-01-01 00:00:00), as seconds,
milliseconds, microseconds or nanoseconds respectively
- `env.is_tty()` to check if stdout is a TTY
- `acton.rts.start_gc_performance_measurement()` to start a GC perf measurement
- `acton.rts.get_gc_time()` to get the GC timings
- `env.is_tty()` to check if stdout is a TTY
- `env.set_stdin(canonical: bool, echo: bool)` to set stdin options
- `canonical` is the default mode which is line buffered where the OS /
terminal offers line editing capabilities and we only receive the input ones
carriage return is hit
- setting `env.set_stdin(canonical=False)` turns stdin into non-canonical mode
where each character as entered is immediately forwarded to the stdin
callback so we can react to it, great for interactive applications!
- `echo` enables (the default) or disables echoing of characters
- `term` improvements:
- More grey shades
- `term.clear` && `term.top` to clear and move cursor to top
- `http.Client.close()` to explicitly close a connection
- Single threaded RTS mode, only used by Windows for now
### Changed
- The work dir and environment arguments of `process.Process` have been moved to
the end as they are optional, making it possible to invoke with fewer args
- Tests run by `acton test` are now compiled with `--dev` and thus have C
asserts enabled, similarly the test.hs that drives the test in the Acton repo
now compile with `--dev` to get C asserts
- `acton test` now runs test for at least 50ms
- `acton test perf` now runs test for at least 1s
- Rename `--only-act` to `--skip-build`
- Acton build cache now uses up to 15GB instead of 5GB
### Removed
- `actonc` no longer supports `--no-zigbuild` / `--zigbuild` (it's now the
default/only choice). It hasn't been tested in quite some time now and the zig
build system works well enough that there is basically no reason to keep the
old system around.
- `actonc` no longer accepts `--cc` since we now always build using the zig
build system which implies the clang version that Zig ships.
- `actonc` no longer supports explicit `--stub` compilation, use `--auto-stub`
### Fixed
- `key` argument in `KeyError(key)` is now of type `value`, not `list[None]`
which it was previously incorrect inferred as
- `file.WriteFile.write()` now truncates file to avoid leftover tail of old
content
- `time.Stopwatch().reset()` now works
- Test crashes are now handled
- If the test program (e.g. `._test_foo`) crashes from an assert or similar,
the top test runner now captures this and reflects it in the output
- Correct dependency path computation in builder
- Makefile now more idempotent to avoid building when nothing has changed
### Testing / CI
- Test on MacOS 14 on Apple M1 / arm64 / aarch64
- Many tests are now repeatedly 100 times to give some idea of stability
## [0.21.0] (2024-03-13)
### Added
- `acton test` testing has been revamped, now doing multiple test iterations
- each test will be run for at least 1ms, for many smaller unit tests this
means the test case run hundreds of times
- all the internals have been rewritten to handle multiple tests results from
a test
- running multiple test iterations gives better performance measurement but
can also show flakiness in tests
- `acton test list` will list all the test names in a project
- `acton test --name foo --name bar` will filter to only run tests named `foo`
and `bar` in a project
- AbE: explain testing with `acton test`
- New methods to interact with environment variables [#1723]
- `getenv` & `getenvb` to read an environment variable
- `setenv` & `setenvb` to set an environment variable
- `unsetenv` & `unsetenvb` to set an environment variable
- The first set of functions work with strings and attempt to automatically
detect the encoding, although utf-8 is the only supported encoding by Acton
right now.
- The functions ending with `b` work with bytes data which can be used for
explicit control over encoding.
- `env.stdin_install` now supports both `str` and `bytes` [#1723]
- It was orignally built to work with `str` which meant it decoded data from
stdin automatically. This assumed utf-8 encoding.
- `env.stdin_install` was then changed so the callback would get `bytes`,
which is technically more correct (it could just be bytes!) but leaves it to
the application programmer to decode data.
- A new interface now offers the best of both worlds:
- `env.stdin_install(on_stdin, encoding, on_stdin_bytes)`
- by specifying `env.stdin_install(on_stdin=my_cb)`, `my_cb` will be called
and get `str` input. The encoding is detected by reading the `LANG`
environment variable or defaults to `utf-8`. It is possible to explicitly
specify the encoding with the `encoding` argument.
- Use `env.stdin_install(on_stdin_bytes=my_cb)` to instead receive bytes
- Acton now always compiles everything from source
- Previously, pre-compiled binary libraries were shipped for the native
target, so on x86_64-linux, there was a libActon.a compiled for x86_64-linux
- Now we just ship the source code of Acton base etc and perform the full C
compilation when we actually run actonc
- The first invokations of `acton build` is slow, taking up to a few minutes,
but as all results are cached, subsequent invokations run in fractions of a
second.
- `~/.cache/acton` is used to store the cache and it is wiped if it reaches
5GB after which it will be automatically re-populated when the next `acton
build` is called
- Low level compiler support for dependencies
- Place Acton project dependencies in the `deps/` folder and the compiler will
automatically find them to allow inclusion of Acton modules from other Acton
projects
- This implements the low level internal support for finding modules in other
projects and correctly linking together the final output
- There is NO support for managing the dependency download itself or even
compiling the dependency
- `SIGABRT` is now automatically handled by the crash handler for automatic
backtrace printing or interactive debugging, just like we already manage
`SIGILL` and `SIGSEGV`
- This simplifies debugging of Acton itself after catastrophic crashes
- `file` module now has methods to interact with file system, like listing
files, making directories, stating files, removing files and walking directory
trees.
- `file.FS.exepath()` returns the path to the current executable
- `acton` now finds `actonc` by looking at its own location rather than assuming
`actonc` is on the path
- Add `--only-act` to only perform Acton compilation and skip C compilation
### Changed
- `acton test` will compile test functions in dev mode to get asserts
- The `dev` and `rel` folders have been removed, e.g. `out/rel/bin` -> `out/bin`
- Printing of compiler pass debug output from individual files, like `acton
src/foo.act --types` will now only print output from the specified name and
not dependencies
- Previously, dependent modules, like if `src/foo.act` imports `bar`, we would
also print the types debug output for the `bar` module
- Printing of compiler pass debug output requires recompiling the module and
thus shortcutting the up-to-date check. By not printing output for included
modules, the included modules do not need to be recompiled thus speeding up
the whole compilation.
- Always link in libprotobuf-c to allow modules to use protobuf tech
- Improved argparse parsing by doing a descent first parsing of options and into
sub-commands with positional argument parsing happening as a second pass
[#1714]
### Fixed
- `acton new foo` now creates a new project `foo`
- Fixed handling of failing tests in `acton test` [#1709]
- Fixed required since self is now parsed as a kwd param [#1715]
- Upgrade GC
- Now ignoring `free()`. This was also previously the case but this was lost
when we upstreamed the new build.zig for bdwgc. It is now back, which is
required for handling the "edge", like where syscall / libc calls do malloc
and then free. uv_fs_scandir is an example of such, which was recently added
and triggered a bug.
- Incremental collection has been fixed on Linux so that it should work,
although it is not supported by the Acton RTS. Incremental collection is
likely much slower for most programs but with better responsiveness. It
could potentially be better for very large heaps as well as overhead of
virtual dirty bit now only hits from a very small heap. It remains to be
seen.
- `testing.test_runner` has been fixed with regards to scheduling, now we
actually wait for a test kind to be completed before proceeding to the next.
Previously for async tests we would spawn all tests immediately and then
proceed to next test category, so we would oversubscribe the tests runners
giving worse performance.
- Various fixes to test output, like count of tess was wrong
- numpy now compiles and runs. There are new tests cases!
### Testing / CI
- Tests, like of builtins etc, now run with `--dev` so we get assertions
## [0.20.1] (2024-02-22)
### Fixed
- Install `acton` frontend in Debian package
## [0.20.0] (2024-02-22)
### Added
- New `acton` CLI which takes over as the main acton program, it should be
called instead of `actonc`, for example `acton build` [#1645]
- it calls into `actonc` for doing most of the work and is currently mostly
just a thin wrapper
- over time, more functionality will be placed in the `acton` frontend
- New `acton test` command which build and runs all test in a project [#1645]
- The compiler now does automatic test discovery
- Simply doing `import testing` and functions with a name starting with
`_test` will be identified as a test and run by `acton test`. The functions
are sorted into categories based on their type signature.
- Run-time reconfigurable `malloc`
- It is now possible to reconfigure which malloc to use during runtime
- All external libraries (libuv for example) are now configured to use a
particular malloc
- Libraries that did not support a custom alloc have now been extended with
support for custom malloc.
- Module constants are placed in non-GC heap
- Using the reconfigurable malloc, we now make use of the "real" malloc (the
one libc provides) during startup of RTS and up past module init. This means
all module constants will be placed on the normal heap and not the GC heap.
- The GC is mark & sweep which means it slows down considerably when there is
a large live heap.
- This makes is a viable option to place large amounts of data as module
constants instead of run time state to speed up programs.
- Fixed size integers arithmetic and comparisons are now unboxed
- For math heavy programs, this can produce a 4x improvement
- A lot of witnesses are now unnecessary and thus removed, reducing GC pressure
- `testing` module has gotten a face lift with much better asserts
- The assert exceptions now include and print the values
- Formatting happens in `__str__` so performance of exceptions is unchanged
- New `snappy` module in stdlib [#1655]
- Snappy is a fast compression library
- Snappy is written in C++ which implied some changes to build.zig and actonc
- It is now possible to print a .ty file by doing: `acton foo.ty`
- Improved size & performance of dictionaries
- An empty dictionary is now completely empty
- For low number of elements, the dictionary is actually a list with linear
searching
- For 5 elements and up, the dict starts to use a hashtable
- `KeyError` & `IndexError` now include key / index so it's easier to
understand what went wrong
### Changed
- The Debian package of Acton now depends on libc 2.27 [#1645]
- Previously depended on the glibc installed on the the build machine (2.36)
since it was expanded from `${shlibs:Depends}`
- Now using Zig 0.12.0-dev.2236
- the build system has changed somewhat so all build.zig files are updated
- DB backend is now optional, include with `acton build --db`
- Using newer version of tlsuv library
- RTS main thread now runs special actors, currently just `Env`
- This enables us to install signal handlers from `Env` since this must be
done from a programs main thread.
### Fixed
- `dict` changed internally to allow storing of `None`
- Support `None` in JSON
- Based on the improved support of dicts
- `lstrip`, `rstrip` & `setdefault` now work properly
- Fix effect of `json.encode()` and `json.decode()` [#1654]
- They are pure!
- Fix `testing.test_runner` when there are 0 tests to run [#]
- Add tests of client & server in `http` module
- `argparse` module now supports nested command parsing
- `argparse` module now supports `--` for literal interpretation of positional
arguments
- Fix compilation of projects that used TLS
- We had missed linking in all necessary mbedtls libraries
## [0.19.2] (2024-01-15)
### Added
- `argparse` now supports optional positional arguments
- like so: `p.add_arg("foo", "Foo thing", required=False, nargs="?")`
- `print()` now takes multiple new input arguments:
- `print(*vals, sep=" ", end="", stderr=False, flush=False)`
- `sep` is the separation character between values, default " "
- `end` is the line ending character, default "\n"
- Output is written to stdout per default, set `stderr=True` to write to
stderr instead
- set `flush=True` to flush the output
- new `--rts-bt-debug` flag that launches interactive debugger (`gdb`) on
SIGSEGV / SIGILL
### Changed
- `print()` now formats to a temporary buffer before printing to reduce
interleaving multiple outputs
- `printn()` has been removed in preference of using `print(foo, end="")`
### Fixed
- `KeyError` now includes the key as part of the error message
- e.g. `KeyError: getitem: key not in dictionary, key: foobar`
- The string formatting of the error message including the key only happens
when the str representation of the exception is necessary, so it does not
incur a performance penalty in normal scenarios
- The key for which the lookup was attempted is stored in the `key` attribute
- Homebrew Formula now somewhat decoupled from Stack version [#1627]
- Idiomatic Homebrew Formulas use system-ghc, i.e. a GHC version installed by
Homebrew itself and not from Stack. Since we specify a Stack LTS resolver,
which is a coupled to a particular version of GHC, there is room for a
version mismatch.
- The latest occurrence of which was GHC 9.4.8 in Homebrew vs Stack LTS 21.13
with GHC 9.4.7. A rather silly small mismatch but that nonetheless breaks
the Homebrew build. This is particularly annoying because it happens only
after we've made a release, so the feedback is too late and thus a
correction version must be released to fix the version mismatch (we've
upgraded to LTS 21.25 with GHC 9.4.8 to align on Homebrew).
- Now `skip-ghc-check` is used to skip the GHC version check to allow some
minor mismatch to happen. We must still ensure that at least the major
version of GHC is aligned, like GHC 9.4.
## [0.19.1] (2024-01-08)
### Fixed
- Upgraded Stack to 21.25 / GHC 9.4.8
- This should hopefully fix the Homebrew build
## [0.19.0] (2024-01-08)
### Added
- Much improved argument "rows" support [#1609] [#1617], including:
- positional & keywords arguments
- default argument values
- `up`, `down`, `left` & `right` in `term` module now accept `n` arg [#1619]
- can move multiple steps in given direction
### Changed
- for `http.Client` the following positional arguments are now keyword args:
- `schema`: defaults to `https`
- `port`: defaults to `80` for schema `http` and `443` for `https`
- `tls_verify`: default `True`
- `connect_timeout`: default `10.0`
### Fixed
- Remove superfluous explicit arguments, now using default values [#1615] [#1618]
- Now possible to print `None` [#1609]
### Testing / CI
- Now testing Telemetrify in GitHub Action workflow as part of CI testing
- Telemetrify is the largest known application written using Acton, so we add
testing of it to the Acton repo to avoid accidental breakage
- Telemetrify main branch is already tested with the latest release of Acton
- now, new changes in acton are also verified against the telemetrify repo
- we test against the `acton-next` branch in the telemetrify repo
- this enables us to make breaking changes in the Acton repo, realize the
break, then write a fix adapting the telemetrify code to the new Acton
change and push this to the `acton-next` branch after which the PR on the
Acton repo can be retried
## [0.18.5] (2023-12-12)
### Testing / CI
- Fix build of APT repo
## [0.18.4] (2023-12-12)
### Fixed
- Add constraint forcing type of self parameter [#1598]
- Let solver use upper bound of type variable when reducing protocol constraints
- Remove subclass constraint on isinstance parameters
- Type error message improvements [#1522] [#1589] [#1596]
- Fix `actonc --debug` [#1591]
- Now also printing zig output
- `--verbose` has been removed
### Testing / CI
- Stop testing on MacOS 11 [#1600]
- Homebrew has dropped support for MacOS 11 so the CI job had to build stuff
from source making it super slow and fragile, thus dropping it.
## [0.18.3] (2023-11-21)
### Added
- `type()` function that provides the type of something as a string [#1587]
- Can be really useful as development tool to get inferred types or similar
- It should not be used for metaprogramming or similar
- This will likely be removed in the future when there is a better way of
debugging types, like a language server
### Fixed
- Only print truly unhandled exception [#1586]
- "Unhandled" Exceptions are no longer printed in actor methods called by
another actor that awaits the return value
- It used to be that when an actor B raised an exception in a method called by
actor A, presuming no try/except handling at all, an `Unhandled exception`
message would be printed in both actor A and B.
- Now we inspect waiting actors and in case there are any, the exception will
be considered "handled" in the actor method that raised the exception
- Cleanup old cruft from Makefile [#]
- Now using zig v0.12.0-dev.1536
- Improved CPU feature detection for Apple silicon
- Some smaller zig build system changes, but it seems to be stabilizing as
there are now docs!
- Acton now builds on Apple Silicon MacOS [#1582]
- It used to not understand the CPU features and thus MbedTLS would fail to
compile
- With zig v0.12.0, the correct CPU features are recognized
- Fix int rounding [#1577]
- Improve DNS error handling in net.TCPConnection [#1573]
- Ignore DNS resolution errors if we're already in connected state
- Given happy eyeball support, we could get a A record and establish a working
IPv4 connection while IPv6 would give an error and be retried continuously,
which is completely pointless when IPv4 is already established.
- Type error now separate error from identifier with `:` [#1583]
### Testing / CI
- Now also testing build / test and running on Ubuntu 23.10
- There are now golden tests for the compilers type errors [#1571]
## [0.18.2] (2023-10-31)
A real fix this time to the Debian APT repo.
## [0.18.1] (2023-10-31)
A small fix for Debian builds.
### Fixed
- Align Debian package building on bookworm / 12
## [0.18.0] (2023-10-30)
### Added
- Exceptions now have a `__str__()` method used to print the exception
- useful for exception types where we want to be able to include dynamic data
- string formatting of dynamic log messages is expensive, so we don't want to
incur that cost for exceptions that are thrown but never printed
- add extra attributes and print them in `__str__()` in your custom exceptions
- Add `testing` module [#1524] [#1552]
- Supports four categories of tests:
- unit tests: `proc() -> None`, think pure functions
- synchronous actor tests, involves actors
- asynchronous actor tests
- env tests
- Improvement to type error messages [#1554] [#1556] [#1559]
- Add `term` module
- a couple of small helpers for doing colored text and similar in terminals
- Add `random.choice()` & `random.choice()` [#1541]
- Add `printn()` is like print but prints without an ending newline
- also flushes output immediately, useful to print progress style output
- this is temporary and will be removed once default argument handling is
properly implemented
- Add `math.pi = 3.141592653589793` [#1539]
- `acton.rts.enable_gc()` & `acton.rts.disable_gc()`
- there are situations in which it can be useful to turn off the GC, such as
during certain test scenarios
- `acton.rts.get_mem_usage()` returns memory usage [#]
- approximate output due to how the GC works
- Add `uri` module [#1560]
- Features a `parse_http()` function to parse a HTTP URL into its parts
### Changed
- Reverted to global single threaded malloc [#1547]
- There have been some reports of errors that could potentially be related to
per-thread malloc or DNS lookups. In caution, the per-thread malloc has been
disabled and will be brought back in a safe way once we've been able to test
it much more thoroughly.
- Integer division by zero now results in exception `ZeroDivisionError`
- for `float`, `inf` is returned [#1530]
- this is aligned with IEEE & languages like C, Zig, Rust, Swift, Julia
- Python raises an exception on float divide by zero
- Haskell Stack updated to LTS 21.13 using GHC 9.4 [#1517]
- Some tests show actonc running ~25% faster
- Presumably thanks to more optimizations in ghc
- C++ seemingly pulled in as a dependency for building Acton itself :(
- Would be nice to use zig c++ but alas, that does not work
- `actonc` now always built statically on Linux
- Previously it was only built statically in release mode
- It does emit some errors / warnings around using dlopen but those are
harmless and can be ignored in our case
- commands in `argparse` now expect `proc()` rather than `pure()`
- JSON encode/decode are now free functions [#1536]
- the JSON encode and decode functions were implemented as methods on an actor
due to an earlier actonc bug
- bug is fixed, so `encode()` and `decode()` are now moved to free functions
in the `json` module
- the old `Json` actor remains and simply wraps the free functions
### Fixed
- Fix error handling in `net.TCPConnection` for single family use [#1546]
- original error handling presumed a dual stack socket and so would wait for
both IPv4 and IPv6 to report an error before propagating the error to the
caller
- now if only a single address family is used, errors are immediately sent to
the caller
- Fix error handling in `net.TCPConnection` for dual stack use [#1527]
- while the original design focused on this use case, there was a bug
- Honor `--root`
- the automatic detection of root actors based on the name `main` would
previously override a manually provided one
- Fix time difference calculation when underflowing
- Fix add / sub duration & comparison for `time.Instant` [#1545]
- Fix premature conversion of input to close converter [#1553]
### Testing / CI
- Now building .debs on Debian 12 / bookworm
- Avoid DNS lookups in test [#1551]
- We have a likely bug around DNS lookups that hits on MacOS. Work around by
using "127.0.0.1" rather than "localhost" in tests.
## [0.17.0] (2023-09-25)
Acton now has exceptions, how exceptional!
### Added
- Add support for exceptions! [#1463]
- The syntactic support for exceptions has existed for a long time but the
underlying run time support was not implemented. It now is!
- It used to be that exceptions would exit the whole application without any
means of catching an exception.
- Unhandled exceptions are now printed to stderr [#1481]
- Do note however that unhandled exceptions will not exit the program nor
even the actors encountering an exception. It will abort the execution of
the current method and nothing else.
- New `http` module [#1485]
- `http.Client` is a HTTP client that supports unencrypted HTTP on port 80 and
HTTPS using TLS on port 443
- `http.Listener` / `http.Server` is a HTTP server component that currently
only supports unencrypted HTTP (due to lack of a `net.TLSListener`)
- Supports chunked transfer-encoding [#1510]
- New `logging` module [#1483]
- Provides logging functionality in an actor centric world
- New `argparse` module [#1499]
- Command line argument parsing!
- `net.TCPConnection`: A new TCP client connection actor [#1398]
- Support DNS lookups so the input address can be a name rather than an IP
address
- It is still possible to connect using an IP address
- Supports Happy Eyeballs (RFC6555) which uses both IPv4 and IPv6
simultaneously to connect using the fastest transport
- Happy Eyeballs is only used for hostnames. If an IP address is provided,
we connect directly to it.
- `net.TLSConnection`: A new TLS client connection actor [#1470]
- A simple TLS client connection actor. It supports disabling TLS certificate
verification for testing purposes.
- Using the MbedTLS library and tlsuv under the hood.
- `net.is_ipv4(address: str) -> bool` tells you if something is an IPv4 address
- `net.is_ipv6(address: str) -> bool` tells you if something is an IPv6 address
- AbE: Documented capability based security [#1267]
- The class name of exception errors is now printed on exception [#1423]
- `actonc build --cpedantic` now works, it was previously only supported for
single files [#1438]
- It is now possible to have mutually recursive definitions between function
defs, classes and actors [#1433] [#1435]
- RTS now uses a per thread malloc implementation [#1456]
- `malloc` is part of libgc which has two flavours, a global malloc with a
lock and a per thread allocator
- During the restructuring to use Zigs build system, the compilation option to
use the per thread allocator was lost. It is now back!
- For parallel workloads across multiple RTS worker threads, there is a clear
bottleneck around malloc... not very surprisingly ;)
- RTS readyQ and per actor message queue has been optimized [#1456]
- There is now a tail pointer which significantly speeds up insertions
- The fields have been slightly reorganized to allow the most important fields
early so it can be fetched in one cacheline
- Before, having many concurrent actors with many outstanding messages would
scale poorly, on an AMD 5950X running the pairs benchmark:
- before:
- 1 actor pair & 1 token: ~4M continuations per second
- 10 actor pair & 1 token: ~650K continuations per second
- 1000 actor pair & 1 token: ~280K continuations per second
- 1000 actor pair & 500 token: ~280K continuations per second
- after readyQ tail optimization:
- 1 actor pair & 1 token: ~3.8M continuations per second
- 1000 actor pair & 1 token: ~3.6M continuations per second
- 1000 actor pair & 500 token: ~700K continuations per second
- after msg queue tail optimization:
- 1 actor pair & 1 token: ~3.8M continuations per second
- 1000 actor pair & 1 token: ~3.6M continuations per second
- 1000 actor pair & 500 token: ~3.6M continuations per second
- This is an artificial benchmark where there is extremely little real work
done, so continuation switching becomes the dominant load. Thus, the
bottleneck becomes the global readyQ. Using more than 1 worker thread only
leads to lock contention and so the benchmarks are for 1 worker thread.
- Since the actor message queue is per actor, it is possible that multiple
worker threads could work faster but in practice they step on each others
toes enough around the global readyQ that it is slower overall.
### Changed
- `net.TCPIPConnection` is removed and replaced by `net.TCPConnection`
- Originally opted to add `net.TCPConnection` now and phase out
`net.TCPIPConnection` later but as there is already a breaking change with
the change of Auth -> Cap so all user code related to networking (and other
things) need to be changed, we might as well change from
`net.TCPIPConnection` to `net.TCPConnection`
- `DNS` actor is replaced with lookup functions [#1406]
- The `DNS` actor is removed, the `lookup_a` & `lookup_aaaa` methods it has
are now free functions in the `net` module, i.e. simply call `net.lookup_a`
- It was originally an actonc shortcoming that lead to the design with a `DNS`
actor - it was intentional, so this is more of a cleanup
- Renamed authentication concept to "capabilities" [#1402] [#1407]
- In order to better reflect the mental model and intuition we want to instill
in users of Acton, Auth objects are renamed to Cap
- With a reference to a capability, we can use that capability. This aligns
with the existing security model for the internal actor domain where an
actor must hold a reference to another actor in order to call its method.
- We want to extend that mental model for all external things in the world
as well.
- All `*Auth` objects now have a `Cap` suffix
- All `auth` args are renamed to `cap`
- `SysCap` is a new capability for functions related to Acton RTS System
internals [#1388]
- `SysCap` is available from `env.syscap`
- `SysCap` is separate from the normal capability hierarchy where `WorldCap`
is the root
- This is to promote the aspiration to restrict access to RTS internal
- While `WorldCap` shouldn't be passed around frivolously either,
capabilities should restricted and delegated, it is still fairly normal to
pass `WorldCap` while the vast majority of programs should not even need
`SysCap`
- The `msg` of exceptions is now optional [#1422]
### Fixed
- Fix control flow bug for `continue` in `for` loop [#1265]
- Fix control flow bug for `return` in `while loop` [#1194]
- Fix comparison of optional types [#1186] [#1506]
- Fix necessary casts for bool checks on tuple field [#1500] [#1504]
- Throw exceptions for unimplemented builtins [#1010]
- Previously printed to stderr and did `exit(1)`
- Now throws a `NotImplemetedError` instead!
- Failed dict key lookups now throw `KeyError` [#1499]
- Previously incorrectly raised `IndexError`
- Document use of `--sigs` in Acton-by-Example [#1405]
- Fix up-to-date check for stub compilation [#1399]
- Improve support for alternate output in actonc [#1395]
- When alternate output is enabled, like `actonc --types`, now uses quiet
mode, thus suppressing various progress messages which interferred with the
alternate output
- Avoid errors when compiling files without a root actor
- Clean up old generated output files [#1411]
- When the source files is moved or removed, also remove the corresponding
output files
- Fix return value of int hashable [#1415]
- Fix module import check [#1420]
- Avoid segfault when exception `error_message` is not set [#1422]
- Bump Zig version to v0.11.0 [#1421]
- Fix `reversed([])` which would `SIGILL` in dev mode [#1455]
- Fix `reversed([1,2,3])` which now returns reversed result [#1455]
- Previous code did the reversal but returned the original value :P
- Fix `i64` comparisons like eq/ne/etc [#1459]
- Would just return the wrong results, like `i64(0) == i64(0)` would not
return `True`. Now works as they should!
- Fix list add with empty list input, like `[1]+[]` [#1461]
- Used to segfault, now works as intended
### Testing / CI
- Stop testing on Ubuntu 22.10 since it is End of Support
## [0.16.0] (2023-07-03)
Primarily addition of simplified TCP reconnection, related fixes and functionality.
### Added
- Add `.close()` and `.reconnect()` on TCP client actor [#1383]
- It is now possible to explicitly close or reconnect a TCP client
- Add RTS Monitor actor in `acton.rts.Monitor()` [#1383]
- The RTS Monitor actor starts a worker monitor per worker thread, each pinned
to a particular worker thread. By doing so, it can retrieve information from
each worker thread in safe manner, honoring the RTS design.
- Currently just supporting getting handles from I/O subsystem.
- Add `env.nr_threads` [#1383]
- Add `set_actor_affinity(wthread_id)` [#1383]
### Changed
- Include DNS query hostname in `on_error` cb [#1382]
- Simplifies retrying a query since we otherwise do not have a persistent
tracking object per query
### Fixed
- Fix `--rts-debug` [#1383]
- Has been broken since new builder but is now fixed
- Fix off-by-one in worker thread wake up [#1383]
- Waking all threads would not consider all threads as there was an off-by-one
error.
- No known problems in the field from this, it was only noticed in development
using --rts-wthreads=1
- The RTS uses at least 4 workers per default
- Use relative source file path in logs [#1383] [#1391]
- `__FILE__`, set by the C compiler, is used to include source file path in
log messages
- Zig uses absolute paths to all files
- now using `-ffile-prefix-map` to make path relative
- project dir name also included, for example `base/rts/rts.c`, to make it
easier to understand from which project a file comes from
- Assignment in multiple branches [#1390] [#1392]
- Only assigning in multiple branches (not before branches) would lead to
redefining shadowing variable of outer scope in low level generated C code
- Info guiding joined assignment has been fixed
### Testing / CI
- Verify we cannot instantiate WorldAuth
## [0.15.3] (2023-06-27)
### Added
- `actonc --cache CACHEDIR` can be used to specify the build cache directory
### Fixed
- static compilation with Musl libc is now possible on Linux [#1372]
- adjusted to adjtimex
- hashing for `int` now supports values outside of `i64` [#1348] [#1367]
- fix `__pow__` to avoid compiler optimization bug [#1371]
- bump Zig version [#1374]
- avoids "File not Found" error
- text color in SVG in docs now follow font color [#1365]
- fix hooking of thread creation to inject signal handler wrapper for stop the
world [#812]
- corrected arguments passed to `on_error` callback of `net.DNS` related lookup
functions [#812]
- .act file specified 2 arguments to the `on_error` callback while the .ext.c
file only sent a single argument
### Testing / CI
- cross-compilation is now tested in CI in all jobs for these targets:
- `aarch64-macos-none`
- `x86_64-macos-none`
- `x86_64-linux-gnu.2.27`
- `x86_64-linux-musl`
- CI uses `--cache` to place build cache in `~/.cache/acton/test-build-cache`,
which is in turn cached in CI
- the cross-compilation testing meant testing went from ~1 minute to ~3, with
caching it remains at around ~1 minute
## [0.15.2] (2023-06-16)
Elevate Acton's build capabilities by completing the adoption of the Zig build
system. Everything, including external library dependencies, builtins, RTS,
stdlib and backend, is now built using build.zig files. A hierarchy of zig
modules are formed, which allow building the entirety of the Acton system with a
single zig build, which is what actonc calls internally. This enables complete
control over all aspects of the low level compilation.
The most striking feature unlocked is likely cross-compilation:
$ actonc --quiet helloworld.act
$ file helloworld
helloworld: ELF 64-bit LSB executable, x86-64, version 1 (SYSV), dynamically linked, interpreter /lib64/ld-linux-x86-64.so.2, for GNU/Linux 2.0.0, with debug_info, not stripped
$ actonc --quiet helloworld.act --target x86_64-macos-none
$ file helloworld
helloworld: Mach-O 64-bit x86_64 executable, flags:<NOUNDEFS|DYLDLINK|TWOLEVEL|PIE>
Libraries for the local platform are still prebuilt and included in the Acton
distribution, hich are used when using the default target, i.e. targetting the
local machine. For any customization to the target, everything will be built
from source.
### Fixed
- revamped low level build, now potentially rebuilding entire Acton system from
source code
- allows cross-compilation and similar advanced features
- use `--target` for cross-compilation, e.g. `--target aarch64-macos-none` to
target an Apple M1 computer
- for Acton projects, there is now a `build-cache` directory that caches all
built output and speeds things up tremendously
- `json` module now correctly encodes and decodes floats [#1345] [#1349]
- zig build of all external library dependencies
- gives us much better control over how libraries are compiled
- much much faster! autoconfig is really slow!
- e.g. building protobuf-c takes a few seconds on a 2015 MBP while with
autoconf, it spends > 1 minute trying to figure out capabilities of the
C++ compiler, despite the C++ parts of libprotobuf-c not being enabled!
- the debian test job now often build Acton in less than 3 minutes, macos-13
often run in ~4 minutes - a real improvement!
- libargp [#1336]
- libbsdnt [#1337]
- libgc [#1344]
- libnetstring [#1325]
- libpcre2 [#1331]
- libprotobuf-c [#1341]
- libutf8proc [#1332]
- libuuid [#1340]
- libuv [#1334]
- libxml2 [#1333]
- libyyjson [#1323]
- remove libbsd & libmd as dependency [#1329]
- only use was of arc4random in numpy, which is now rand using()
- backend is now built using zig [#1346]
- use curl instead of git clone to fetch dependencies [#1343]
- much faster and reduced disk usage
### Testing / CI
- caching has been vastly improved in CI
- based on the new zig build system, we utilize zigs excellent caching
capability by using a single zig cache for the entire build of Acton. In CI,
we cache the zig-cache directory, so we don't actually have to recompile
files at all. Some CI runs now take less than 2 minutes to build Acton!
- we should be able to trust Zigs caching to do the right thing, if files are
modified it will notice!
- testing of the Homebrew Formula has been removed [#1338]
- since some time, this test job has been intermittently failing, or rather
only intermittently passing as most of the time it fails
- to avoid lots of errors in CI, the job has been removed
- the failures are likely coming from some change in brew behavior
- we use a fairly hacked up and not supported workflow
- several attempts to fix it have been unsuccessful and we're unable to spend
more time on it right not
- removed test of compiling Acton on Ubuntu 20.04 due to problems with stack
- note how executables built by actonc are still compatible with Ubuntu 20.04
## [0.15.1] (2023-06-02)
A better strategy for constraint solver results in vastly lower constraint
solving times and thus reduced overall compilation times. Large improvements in
code generation resulting in less memory allocations and thus a much lower load
on the GC, yielding much better runtime performance.
The internal compilation of generation C code has been revamped, now more
structured and simplified in many ways, internally making use of the Zig build
system which in turn unleashes a lot of benefits.
### Changed
- release builds now use `-O3` and dev builds use `-Og` [#1270]
- Collection overloading has been removed [#1316]
- It was previously possible to overload collections like dict / Mapping
- {} now always means the builtin dict
### Fixed
- Faster constraint solver through new strategy [#1316]
- Evaluates vastly fewer possibilities
- One application used to take over 10 mins for constraint solving which now
runs in roughly 10 seconds - woohoo
- New second stage compilation of generated C code [#1249] [#1304]
- new `builder` performs "second stage" compilation of the C code that
`actonc` generates into object files, archives and executable binaries
- Built on Zig's Build System, gaining all that it offers
- Very good caching, dependency detection, up-to-date checking and concurrency
- Custom compilation to make `builder` itself portable
- Compilation can now be more clearly separated in two steps:
- step 1: `actonc` compiles `.act` to `.c` & `.h`
- step 2: `builder` compiles `.c` & `.h` to `.o` & `.a` & executables
- Up-to-date checking in actonc adjusted to only compare `.act` with `.c` &
`.h` output
- `builder` does a fantastic job of following dependencies (looking at
`#include` statements etc) to figure out when things need to be recompiled
- All of this is internal, `actonc` calls `builder` under the hood, much like
it earlier called `cc` under the hood
- `--no-zigbuild` can be used to force old compilation method
- `--no-zigbuild` will be removed in the future
- Much faster build of Acton itself using prebuilt libActonDeps [#1279] [#1282]
- Uses a checksum of git refs of all lib that constitutes libActonDeps
- If any dep lib is updated to use new version, libActonDeps will be rebuilt
- Uploaded to github.com/actonlang/libactondeps and downloaded on demand from
normal Makefile, thus used for local builds and in CI
- Falls back to local compilation if prebuilt version is not available
- builtins, RTS & stlib now organized as an Acton project called `base` [#1309]
- More streamlined towards imagined design of how project dependencies will
work in the future, meaning less special kludges
- Cleans up include paths and similar, avoiding potential naming conflicts
- builtin code is now generated [#1256] [#1260]
- `__builtin__.c` and `__builtin__.h` are now generated from `__builtin__.ty`
at build time, whereas they were earlier checked in to git, having once been
generated but heavily modified by hand
- given complexity of these files, it is difficult to keep the files up to
date when there are changes to the `CodeGen` pass in `actonc`
- `actonc` CodeGen pass is now infused with some of the bespoke customizations
done for builtins, other customizations have been removed to streamline the
whole thing or inserted into .ext.c file to use the "standard way of
customization" (what an oxymoron)
- Better performance through code generation improvements [#1263] [#1274]
- Code generation has been improved, primarily to avoid unnecessary
allocations, thus reducing pressure on GC, leading to improved performance
- One application that ran in > 12 minutes now run in < 2 minutes
- `xml` module now correctly parses default namespace [#1262]
- address `xml` bugs with more null checks [#126]
- Switched to a nightly version of zig [#1264]
- pre-release version of zig v0.11
- we still pin to this particular zig version which goes through the Acton CI
testing so there is relatively low risk of this silently breaking something
- Document `after` and encourage not using `sleep` [#1269]
- `actonc` now transparently passes through zig output [#1277]
- treats subprocess output as bytestring instead of trying to decode it
- we only pass it through anyway, there is no analysis done on it
- avoids errors seen when not using UTF-8 locale, like when `LANG` is unset
(effectively defaulting to `C`)
- Remove bunch of old code, irrelevant tests, old gen env scripts ect [#1278]
- `math` module switched from stub style to .ext.c style [#1309]
- Add missing MacOS headers [#1309]
- Remove note on segfault in AbE that's no longer valid [#1303]
### Testing / CI
- Added macos-13 as test target in CI [#1258]
- New CI job to build libactondeps and upload to "cache" repository [#1283] [#1284]
- Also using cached for CI builds (as well as local)
- MacOS CI builds 12 -> 6 minutes, Linux ~8 -> 4 minutes
- brew-macos is still slow, but we get quicker feedback of failures looking
at test-macos & test-linux jobs
- Fixed Homebrew build by applying workaround
- Broke due to upstream changes and is still broken with default suggested
config in `brew new-tap`
## [0.15.0] (2023-04-26)
### Added
- `actonc` is now statically linked in the Acton APT repo packages [#1148]
- enables development using Acton on Ubuntu 18.04, Debian 10 and distributions
of similar age
- static linking only works when the build platform is a slightly older Linux,
it works on Debian 11 which we are using, while on a newer Debian (testing
as of December 2022) the compilation fails
- our static compilation is conditioned on `STATIC_ACTONC=true`, which is set
in our `build-debs` CI job which builds the .deb packages used in the Acton
APT repo
- local compilation still defaults to a dynamically linked `actonc`
- Parallel GC marking, speeding up mark phase significantly on computers with
many cores [#]
- Up to 16 parallel threads are used for marking
- Add `sorted()` function [#1211]
- Uses timsort, which is the same sorting algorithm used by Python and Java's
Arrays.sort()
- Add `re` module for regular expression matching [#1208]
- Offers `match()` function to match on text,
- Unanchored pattern matching, unlike the Python equivalent which is
anchored at the start per default (seems highly unintuitive)
- Completely revamped `time` module [#1188]
- The high level interface is now oriented based on the two common usage
patterns of measuring elapsed time or telling the current date and time.
- `Stopwatch` measure elapsed time
- `time.now()` now returns a DateTime object, which is a higher level object
- New fixed width integers: i16, i32, i64, u16, u32, u64 [#1202] [#1202] [#1203]
- Backend queue subscriptions now done in bulk [#1127]
- An actor mailbox is mapped to a queue in the backend
- For every actor creation, the RTS would create and subscribe to the
corresponding queue.
- There's a new interface for queue subscriptions where individual queues are
grouped together into queue groups, so the RTS only needs to subscribe to a
group once
- New acton projects are now git initialized [#1185]
- Using `actonc new foo` to create a new Acton project, we now check if git is
available and if so, initialize the repository. Also include a `.gitignore`
- Allow overriding number of worker threads [#1199]
- It's been possible to set but we always used a minimum of 4, so even setting
threads to 2 you would end up with 4. It can be really useful for debugging
to run on a single WT, so honoring this is useful.
- Add list methods `clear`, `extend` & `pop` [#1206]
- New `--rts-no-bt` option to disable automatic backtrace printing [#1226]
- Automatic backtrace printing is nice for the normal case where one might run
a program and do not have core dumps enabled
- However, when doing actual debugging, one usually enables core dumps and
analysis it using a debugger interactively, in which case it's only annoying
to get a couple of screenfuls of backtrace in the terminal on every
iteration
- Laid foundation for exception handling [#1228]
- Handles exceptions for CPS converted code
- Proc style functions do not currently handle exceptions properly
- Not fully enabled just yet, as it requires some more work
- `int` literals between 0 and 256 are now statically allocated [#1235]
- Python uses the same trick for -5 to 255 for speedup for commonly used
integers
- Acton literal negative integers are really not negative integers but an
expression of "minus" and the integer 5 so we cannot currently do the same
trick for common negative values, like -1 etc
- lists can now shrink to reduce memory usage [#1237]
- When list length goes below half, the list will be reallocated and copied
over to a new memory area
### Changed
- bash completion for `actonc` now completes `.act` files [#1246]
- `TCPIPListener` interface has changed for callback registration [#1181]
- The `on_receive` and `on_error` handler for individual client connections
(`TCPListenConnection`) are now registered after instantiation of each
`TCPListenConnection` actor by calling `cb_install()`.
- This is most appropriately done in the on_accept callback.
- Unlike the old pattern, where we provided these callbacks up front to the
`TCPIPListener` actor, having them registered per client connection
naturally opens up to having different handlers per client.
### Fixed
- Fix `@property` handling & inference [#1207]
- Fix bug in dict `__eq__`, so equality check now works [#1144]
- `min()` & `max()` now work as they should [#1150]
- `isinstance` now works correctly [#1124]
- Fix compilation with return in nested branches [#1162]
- Signal interrupts are now properly handled in acton.rts.sleep() [#1172]
- Previously, a signal would interrupt the sleep and it would simply not sleep
long enough. Now, if interrupted, the sleep is called with the remaining
time until the full duration has passed.
- Fix worker thread indexes in WTS rtsmon interface [#1176]
- `bool([])` now correctly returns False [#1193]
- Correct `hex`, `bin` and `ascii` functions [#1196]
- `actonc docs --signs` now works [#1197]
- Correct pid is now reported in rtsmon [#1177]
- Atomic mallocs are now used where possible to speed up GC [#1225]
- The GC does not need to scan the value of a `str` or `bytearray`, so they
are now atomically allocated which means the GC will skip scanning them
- Document more list operations [#1136]
- Explain named tuples [#1192]
- Improved some parser errors [#1198]
- Now using zig v0.10.1 [#1174]
- Update to LTS 18.28 [#1141]
- Internal name mangling has been changed [#1160]
- builtins has been reorganized [#1169]
- New `make clean-all` target to clean move stuff [#1210]
### Testing / CI
- Add Ubuntu 18.04 as test platform in CI [#1149]
- It's not possible to build Acton on Ubuntu 18.04
- As actonc is now statically built, the version built on Debian now also runs
on Ubuntu 18.04!
- Test all available operations on lists [#1137]
- Test all available operations on dicts [#1140]
- Concurrent builds disabled on MacOS due to intermittent failures [#1145]
- web page rebuild now triggered on changes to docs/acton-by-example [#1216]
- Deb package now also gets a deterministic name [#1217] [#1219] [#1220]
- Makes it much easier to install the pre-built tip packages for testing / CI
etc on other repos
## [0.14.2] (2022-11-27)
### Fixed
- Improve `actonc` performance [#1119]
- The constraint solver can have a massive performance impact on the
compilation process, in particular if it has a very large amount of
solutions to evaluate.
- The number of alternative solutions had too little weight during constraint
sorting which would result in a very large amount of potential solutions to
evaluate. An example program took 31 minutes to compile, which after the fix
compiles in milliseconds.
- For a 100 constraints, with the wrong strategy we might need to evaluate
5^100 solutions (heat death of universe etc) whereas if we do things
correctly we can solve all constraints in perhaps 100*3 tries. Exponential
is exponential.
- Fixed size `i64` integer type is now instantiable [#1118]
- Improved str to int conversion [#1115]
- Corrected str `.split` and `.splitlines()`
- Correct DB server & client comm loop select handling [#1111]
- Ignores EBADF and have ensured this design is correct with regards to timing
of invalid fds.
- Drop explicit `gcc` dependency for Debian package [#1110]
- Haskell GHC still depends on it though, so it still gets installed.
- Use slightly newer bsdgc / libgc version [#1112]
- Slight build simplification as we've upstreamed some modifications.
## [0.14.1] (2022-11-14)
### Added
- `actonc --cc` to specify which C compiler to use to compile a module and
binary executables [#1103]
- Note that the Acton system is still compiled by `zig cc`. On Linux we are
targeting GNU libc 2.28, which might affect compilation of individual
modules or executables.
### Fixed
- `float.__ge__` is now working correctly [#1105]
- Removed incremental operations from integers [#1106]
- Improved `int` to `str` conversion [#1107]
## [0.14.0] (2022-11-10)
Acton RTS now does garbage collection!
### Added
- The Acton RTS now does garbage collection [#1091]
- Using libgc a.k.a the Boehm-Demers-Weiser garbage collector
- The GC stops the world to perform garbage collection during which all Acton
RTS worker threads are paused. It is likely this will be visible as pauses
of the whole system.
- Performance appears to be largely on par with and without GC but this is
based on small artificial programs.
- It is possible to disable the GC at run time by setting the environment
variable `export GC_DONT_GC=1` before starting the Acton application
- This will be removed in the future when the GC has been field proven.
- Long term is to implement an Acton specific GC that can, for example, avoid
stop the world events by doing collection per actor. This is quite far into
the future. Until then, this will have to do!
## [0.13.1] (2022-11-10)
### Changed
- Allow `_` as a dummy variable name [#1020] [#1061]
- `_` can be used in an assignment to effectively throw away a result
- Unlike using a variable like `dummy`, `_` acts as a wildcard from a type
perspective, so that we can do `_ = 3` and `_ = "a"`, while if we attempt to
use another dummy variable name we will get a type error as we try to assign
it values with different types
- `__self__` has been renamed to `self` [#1056]
- it is a reference to the own actor and holds the "external" view, i.e. it
can be passed to another actor as a reference to the local actor
### Fixed
- Correct DB client comm thread to avoid potential deadlock [#1088]
- Incorrect handling of error return status from select meant we could attempt
to read on fds that had no data and thus the comm thread would deadlock.
- Now we do proper error handling, always continuing for another spin &
attempt at select in case we get an error back.
- The (under development) garbage collector (GC) uses signals to instruct
threads to pause for stop the world events and thus we end up interrupting
the select loop a lot more frequently than before, thus surfacing this bug.
- Correct DB client comm thread to avoid busy waiting [#1089]
- On Linux, using `select()` with a timeout, if the select is interrupted the
timeout value will be modified to reflect the time not slept. Thus the next
select in our comm thread loop would sleep for a shorter period of time.
Depending on the timing of the interrupt, the sleep might be shortened to
effectively form a busy wait.
- The (under development) garbage collector (GC) uses signals to instruct
threads to pause for stop the world events and thus we end up interrupting
the select loop a lot more frequently than before, thus surfacing this bug.
- Fixed by always resetting the timeout value in the loop.
- Make RTS DB clients stick to one partition [#1087]
- Make sure RTS (a DB client) does not hop between different DB server
partitions even if they learn about disjoint gossip views.
- Prevents incorrect operation when DB servers are not aware of each other but
are "joined" by a RTS that see all the servers.
- This scenario is most easily reproduced by starting DB servers without
specifying a seed, and so the DB servers won't see each other, and then let
a RTS connect to the DB servers, which then sees a view of all 3 servers.
- This is now rejected as invalid.
- Using vector clocks to determine and reject invalid views. Very elegant =)
- Correct `time.monotonic()` [#1097]
- It returned a wildly incorrect results as the nanoseconds part was not
properly added up with seconds.
- Include argp-standalone library in libActonDeps [#1058]
- No more external dependencies!
- argp is available as part of the system on GNU/Linux but on MacOS we have
relied on the argp-standalone package installed via brew. We now prefer to
use our own on both Linux and MacOS.
- Acton system is now compiled with `-Werror` to improve code quality [#1060]
- There are some exceptions to this but the overall goal is to be essentially
free of compilation warnings
- Fix bug in truediv for `int` [#1076]
- Fix bad codegen of classname argument to `isinstance()` [#1055]
- Correct effect declaration to `mut` for some builtin protocols [#1053]
- Method decorators like `@staticmethod` now work [#1054]
- Added lost constraints inferred on target expressions [#1050]
- Avoid undefined behavior in builtin object hash [#1065]
- Clean up library include paths etc [#1068] [#1077] [#1080] [#1092]
- Made possible by including all of our external dependencies in libActonDeps
### Testing / CI
- Add back testing on Ubuntu 20.04 [#1093]
- libxml2 requires a newer automake (1.16.3) than is available on Ubuntu 20.04
- We fix this by hacking the configure.ac file to require the version
available on Ubuntu 20.04 (1.16.1)
## [0.13.0] (2022-11-04)
New "deactorizer", which unlocks proper async / sync actor method calls.
### Added
- Added new "deactorizer" pass in compiler [#374]
- No real user visible change, like no change in syntax, but we now properly
compile programs with regards to async / sync calling behavior of methods.
- Briefly, an actor method called from the local method is called directly.
This effect is called "proc". Remote actor methods are normally called
asynchronously and these are called "action". If we assign the return value
of an action, we are locking for a synchronous behavior which is achieved by
an await. These semantics are now correctly implemented.
- In particular, passing methods as arguments, a method might not know whether
it is passed an action or proc and thus needs to handle this in a generic
way. This is particularly tricky as we don't want to to any run time
inspection of arguments and thus need to have it all figured out at compile
time.
- Many many many other things are fixed through the merge of the new
deactorizer. There are improvements and fixes to various passes in the
compiler. This has been in the works for almost a year.
- Added `--auto-stub` to `actonc` [#1047]
- Enables automatic detection of stub mode compilation
- Extended actor argument pruning analysis to honour `NotImplemented` [#524]
- Pruning analysis prunes away arguments that are not used under the lifetime
of an actor, e.g. an argument only used for actor body initialization code.
Pruned arguments are not persisted.
- Pruning analysis does not cover C code, so when one or more methods are
implemented in C and defined as `NotImplemented` in the Acton module, we
cannot reliably determine what arguments are used or unused.
- The safe choice is to assume all arguments are used, which is what we are
now doing.
- This removes a bunch of `_force_persistance` methods in stdlib.
### Changed
- Default is now to not automatically detect stub mode [#1047]
- Use `--auto-stub` to enable automatic stub mode detection
### Fixed
- Now using zig v0.10.0, which was recently released [#1029]
- Previously using a nightly build of v0.10
- Correct arithmetic operations using hexadecimal literals [#1027]
- Build actondb using zig with -target [#1003]
## [0.12.0] (2022-10-27)
Edvin's second birthday, only 10 minor releases behind Acton ;)
### Added
- Zig is now used as the C compiler for Acton [#972]
- Many parts of Acton, like the run time system, builtins and parts of the
standard library are written in C
- actonc compiles Acton programs into C which are then compiled into binary
executables using a C compiler
- zig is now used for both of these use cases
- zig is bundled with Acton so that we know what version of zig we get, which
is the same across Linux and MacOS
- Acton programs on Linux are now backwards compatible to GNU libc v2.28
- Previously, acton programs would be built for the GNU libc version on the
compiling computer, making it impossible to run on older distributions
- Now compatible with for example Ubuntu 20.04 LTS & Debian 10
- This is made possible by zigs incredible cross-compilation functionality,
which isn't just about targetting other OS, CPUs but also older libc
versions
- v2.28 appears to be the oldest version we can practically target without
code changes, even earlier versions fail compilation
- We could reduce backwards compatible, for example by targetting glibc 2.31,
if we find things that we would like access to, i.e. don't regard glibc 2.28
compatibility as a hard promise
- Added `--always-build` to actonc [#988]
- Used in test suite so that we always force compilation in order to ensure
valid test results
- `actonc` argument parsing now done using sub-parsers, allowing greater freedom
in constructing more complex commands [#976]
- All external library dependencies are combined in one .a archive [#849]
- Decouples library dependency in builtins, RTS & stdlib from actonc compiler
arguments
- All external library dependencies are now built from source [#984]
- Allows us to compile them with zig, thus power to select target libc
- Add `xml` module [#835]
- Offers simple `encode()` and `decode()` operations
- Based on libxml2
- The `int` type now supports arbitrary precision [#146]
- Add some big numbers!
- The previous implementation of `int` was as a signed 64 bit integer, this is
now available as the `i64` type in Acton, although its use is currently
quite limited.
- Longer term, fixed size integers like `i64` or `u64` (for an unsigned) are
available and can be chosen for high performance use cases. Developers
familiar with this level of coding are likely able to make an informed
choice about what integer type to choose. Using `int` for the arbitrary
precision type is the safer choice which will make most users happy.
- Using BSDNT library, which is a reasonably fast C implementation of
arbitrary precision types and arithmetic operations. It is not as fast as
MPL but has a more liberal license.
### Fixed
- Fixed seed arg parsing in actondb [#900]
- Avoid crash during TCP client resume
- DB now using logging rather fprintf(stderr, ...)
- Reduce unprovoked CPS & 'rtail' bugs [#949]
- Update docs for --root & `runacton` [#950]
- `file.ReadFile` can now read arbitrarily large files [#955]
- RTS does proper error handling of DB interaction [#957]
- This is a huge improvement!!!
- The run time system now properly reads the return code from all DB query
operations and acts appropriately. For example, lacking a quorum, the RTS
will continuously retry an operation until quorum can be reached.
- For some failures a larger chunk of operations needs to be retried, i.e. we
can't just wrap up a small function in a retry loop but need a larger retry
loop around a group of operations.
- DB API now returns a minority status which the RTS can and does react on
- Typical example is with 3 DB nodes and a commit goes through on 2, i.e.
with a quorum and is thus considered a success, however the 3rd node
rejected it because of a schema mismatch. The RTS can now be notified
through the minority status and attempt to repair the schema.
- A typical example of schema repairs necessary are for the queues, which
are dynamic. Every actor gets a queue in the database, so when new
actors are created, new queues also need to be created and if a
particular DB server is not up when the queue is created, it will be
missing and needs to be repaired later on.
- We should have proper sync up between DB servers, so that they query
each other and converge on the latest state. Until then, repair
initiated from RTS is our way of fixing it.
- Notify gossip view to clients (RTS) from agreement round leader [#951]
- For example, in this scenario:
- db1 is started
- RTS is started & connected to db1 but unable to progress due to no quorum
- db2 is connected, gossips with db1 and we now have quorum
- RTS continues to be stalled as it is never notified about db2 and thus
unable to reach a quorum
- Avoid MacOS quarantine shenanigans that kills actonc [#971]
- MacOS has some quarantine concept, so like if a file is downloaded from the
Internet, it is marked as quarantine and the user is asked "Are you sure you
want to run this" after which the quarantine flag, which is stored as a file
system extended attribute, is cleared.
- Somehow we trigger this quarantine, presumably by that we overwrite, through
cp, a binary executable that macos has run and this triggers it to set the
quarantine flag. The effect is that whenever we execute actonc, MacOS kills
-9 it, which is obviously rather annoying.
- By copying to a temporary file and then moving it in place, we avoid MacOS
setting the quarantine flag. We already did this, though for other reasons,
for actondb, so in a way this is a unification for the files in bin/
### Testing / CI
- Simplify and clean up RTS DB test orchestrator [#941] [#973]
- Stop testing on Ubuntu 20.04
- It's not possible to compile libxml2 on a stock Ubuntu 20.04 as a newer
version of automake is required than is shipped
- We mainly want to uphold run time compatibility with Ubuntu 20.04, like it
should be possible to run Acton applications but utilizing Ubuntu 20.04 as a
development platform for Acton is not a high priority target, thus dropping
it is quite fine.
- Revamp Increase timeout
- Avoid kill -9 on macos [#969]
- MacOS quarantine functionality thinks we are doing something fishy and kill
-9 our process
- Worked around by doing cp & mv instead of just a cp
## [0.11.7] (2022-10-03)
Many important fixes for RTS/DB and the language in general!
### Added
- Bash completion is now part of the Debian packages & brew formula
### Changed
- actondb now uses a default value for gossip port of RPC port +1 [#913]
- The gossip protocol only propagates the RPC port & parts of the
implementation has a hard-coded assumption that the gossip port has a +1
offset
- In order to avoid configuration errors, the default gossip port is now RPC
port + 1 and if another gossip port is explicitly configured, an error log
message is emitted on startup.
- While this is marked as a change, it could really be considered a fix as any
other configuration of the system was invalid anyway.
### Fixed
- Fixed include path for M1
- /opt/homebrew/include added to header include path [#892]
- Actually fixes builds on M1!
- This has "worked" because the only M2 where Acton was tested also had header
files in /usr/local/include but on a fresh install it errored out.
- Fix up-to-date check in compiler for imported modules from stdlib [#890]
- Fix seed arg parsing in actondb that lead to "Illegal instruction" error
- Fix nested dicts definitions [#869]
- Now possible to directly define nested dicts
- Avoid inconsistent view between RTS & DB in certain situations [#788]
- If an RTS node was stopped & quickly rejoins or if a transient partition
happens and the gossip round does not complete before the partition heals.
- We now wait for gossip round to complete.
- This ensures that local actor placement doesn't fail during such events.
- Fix handling of missed timer events [#907]
- Circumstances such as suspending the Acton RTS or resuming a system from the
database could lead to negative timeout, i.e. sleep for less than 0 seconds.
- The libuv timeout argument is an uint64 and feeding in a negative signed
integer results in a value like 18446744073709550271, which roughly meant
sleeping for 584 million years, i.e. effectively blocking the RTS timerQ.
- It's now fixed by treating negative timeouts as 0, so we immediately wake up
to handle the event, however late we might be.
- Timer events now wake up WT threads after system resumption [#907]
- Worker Threads (WT) are created in `NoExist` state and should transition
into `Idle` once initiated, however that was missing leading to a deadlock.
- This was masked as in most cases, a WT and will transition into `Working`
once they've carried out some work and then back into `Idle`
- `wake_wt` function, which is called to wake up a WT after a timer event is
triggered, wakes up threads that are currently in `Idle` state, if they are
in `NoExist`, it will do nothing.
- If there is no work, such as the case after system resumption from the DB,
WTs will stay in the `NoExist` state and then `wake_wt` will do nothing, so
the system is blocked.
- WT now properly transition into `Idle`.
- Only communicate with live DB nodes from RTS DB client [#910] [#916]
- When the RTS communicates with the DB nodes, we've broadcast messages to all
servers we know about. If they are down, they've had their socket fd set to
0 to signal that the server is down. However, fd=0 is not invalid, it is
stdin, so we ended up sending data to stdin creating lots of garbage output
on the terminal.
- fd -1 is used to signal an invalid fd, which prevents similar mistakes.
- The DB node status is inspected and messages are only sent to live servers.
- Avoid segfault on resuming TCP listener & TCP listener connection [#922]
- Invalidate fds on actor resumption [#917]
- Remove remaining ending new lines from RTS log messages [#926]
- Remove ending new lines from DB log messages [#932]
### Testing / CI
- Rewritten RTS / DB tests [#925] [#929]
- More robust event handling, directly reacting when something happens, for
example if a DB server segfaults or we see unexpected output we can abort
the test
- Now has much better combined output of DB & app output for simple
correlation during failures
- Test orchestrator now written in Acton (previously Python), at least async
IO callback style is better supported to directly react to events...
## [0.11.6] (2022-09-20)
### Fixed
- Homebrew Formula now includes util-linux for Linux
- required for <uuid/uuid.h>
## [0.11.5] (2022-09-20)
### Fixed
- Homebrew Formula test [#882]
- Homebrew Formula now pins GHC dependency to version 8.10 [#885]
- This is aligned with the stack resolver version we're currently using
- actondb is now statically linked with protobuf-c [#887]
- Found in brew linkage testing, which should now pass
## [0.11.4] (2022-09-19)
### Testing / CI
- Minor correction to Homebrew release automation
- This is silly...
## [0.11.3] (2022-09-19)
### Testing / CI
- Minor correction to Homebrew release automation
## [0.11.2] (2022-09-19)
There are additions but they're so minor you get 'em for free in a patch
release! ;)
### Added
- Add runacton wrapper to run .act files using shebang [#238]
- Write an Acton program in a .act file and add shebang line at top:
- `#!/usr/bin/env runacton`
- ... and then run the .act file. It will be seamlessly compiled and executed!
Magic *whosh*
### Testing / CI
- Homebrew Formula moved to actonlang/acton repo [#868]
- Building a brew bottle is now part of regular CI testing
- Ensures that our Homebrew Formula is correct with regards to dependencies
etc, which has previously been a long standing issue
- mirrored to actonlang/homebrew-acton when we release
- Retry DB test jobs [#853]
- No longer have to manually re-run CI jobs on failures
- Retry just the DB test itself, which takes a few seconds instead of
rerunning entire CI job which takes minutes
- New automatic release process
- Removes adding git tag as manual step
- Now push branch `release-vX.Y.Z` updating `common.mk` & version in
`CHANGELOG.md`, once this PR is merged, a new workflow adds the git tag
which in turn triggers the release build
## [0.11.1] (2022-09-14)
### Testing / CI
- Fix APT repo job
## [0.11.0] (2022-09-14)
### Added
- Apple M1 / M2 CPUs are now supported [#823]
- aarch64 calling conventions are different for variadic vs fixed functions
and this is a problem when we alias a fixed function as a variadic function,
which is exactly what we did in a number of places in the stdlib where we
manually write C code
- Now fixed by calling $function2, $function3 etc for 2 vs 3 args
- `actonc new foobar` will create a new project called foobar according to the
standard project directory layout
- Completely rewritten IO system & RTS workers [#698]
- libuv is now used for all IO operations instead of our own home grown IO
subsystem.
- Rather than a single thread dedicated to IO, all RTS worker threads now also
perform IO work. IO actors are pinned to a particular worker thread on
initialization.
- New `net` module [#733]
- replaces `env.connect()` & `env.listen()`
- adds DNS lookup functions
- New `process` module [#752] [#796] [#797] [#798] [#799] [#800] [#801] [#804]
[#808]
- runs sub-processes
- New `file` module which allows reading and writing files [#806]
- Replaces `env.openR` & `env.openW`
- New `json` module to encode and decode Acton data to JSON document (strings)
[#829]
- built on yyjson C library, which is a very fast (3.5GB/s) JSON library
- Do token based authentication
- Capability based authentication has previously been based around access to
the env actor, which was initially fed into the system as an argument to the
root actor
- We wanted to modularize the code of the env actor and so instead we've opted
to use a token based authentication scheme
- A WorldAuth token is passed to the root actor, accessible as `env.auth`
- Tokens are organized in a hierarchy, e.g.
- WorldAuth > NetAuth > TCPAuth > TCPConnectAuth
- Performing actions always require most specific auth token
- This is to encourage users NOT to pass around the WorldAuth token but make
it more specific
- For example creating `net.TCPIPConnection` requires a `TCPConnectAuth` token
- actonc now outputs some information about what it is doing per default [#840]
- Previous quieter output can be achieved with `--quiet`
- `--timing` includes extra timing information on how long compiler passes and
other operations take
- all `--verbose` output now under `--debug`
- actonc now takes a lock on a project when compiling, which ensures that two
invokations of actonc to build the same project do not step on each others
toes [#760]
- lock is implemented using flock(), so even if actonc dies and lock file
stays in place, it is not considered locked (flock only keeps lock while
process that acquired lock is running)
- Our own stdlib is built concurrently with development and release profile,
which can now be run "concurrently", i.e. we do not have to ensure
serialization of these two builds from the Makefile and since all other
targets are run concurrenctly this simplifies the Makefile quite a bit,
however since there is a lock there won't be an actual concurrent build
- actonc now automatically sets the root actor to `main`, if a program contains
such an actor. This means `--root` argument is mostly superfluous now [#726]
- actonc --root argument now takes a qualified name, like <module>.<actor>
[#628]
- this is required to build an executable in a project with:
`actonc build --root test.main`
- RTS has improved logging, including timestamps, log levels etc. Also supports
file output [#584]
- Log output is sent to stderr
- RTS worker thread id is included so it is now easier to follow what a
particular thread is doing.
- stderr output has millisecond time resolution
- file output (--rts-log-path) has nanosecond precision
- Using pretty, short relative paths
- ActonDB has improved logging, including timestamps, log levels etc and
supports file output [#588]
- supports logging to file with --log-file
- similar implementation as RTS (based on same log.c library but modified)
- actonc automatically detects stub mode compilation based on presence of .c
file [#601] [#624]
- actonc supports new .ext.c style definition of C functions where individual
functions in an .act file can be externally defined in the .ext.c file by
using `NotImplemented` as the function body [#706]
- actonc is now aware of development / release profile [#599] [#612]
- output placed in correct location, i.e. out/rel or out/dev
- actonc now supports custom compilation of modules via Makefile [#602]
- if a module is to be stub compiled (i.e. there is a .act file with a
corresponding .c file) then if there is also a Makefile in the project root,
actonc will run make for the corresponding target, e.g. `make out/rel/foo.o`
- actonc now has concept of commands [#608]
- like `actonc build` which will build an Acton project
- stdlib is now compiled from actonc as a Acton project [#599]
- `__builtin__.act` has been moved from stdlib to `builtin/ty`, which is also an
Acton project [#623]
- `__builtin__.act` really is special, like it's an implicit dependency for
everything else, and trying to add extra logic to get it to build first when
building the stdlib project doesn't make sense; it's now special rules in
the Acton Makefile
- Improve DB schema creation messages [#586]
- Messages contained "test", which is misleading. The DB server creates the
schemas, i.e. the schema is hard-coded. This is per design and a
simplification (no need for schema management RPCs) as the DB and RTS are
tightly coupled anyway.
- ActonDB will now gossip RTS node membership, forming the foundation for doing
distributed computing
- ActonDB monitor membership information now contains all nodes [#645]
- RTS mon now has a membership view [#645]
- `bytes` type added [#655]
- Library dependencies are now included in the Acton distribution [#698]
- Added `__repr__` method to class value & subclasses [#685]
- Added Ord instances for lists & dicts [#719]
### Changed
- `after` now takes a float argument [#846]
- Allows sub-second delays
- IO subsystem has been replaced with libuv
- `env.connect()`, `env.listen()` has been replaced with `net` module, i.e.
`net.TCPIPConnection` and `net.TCPListener`
- file access via `env` has been replaced with the `file` module
- RTS log output is now sent to stderr rather than stdout
- `actonc dump foo.ty` now takes the filename of the `.ty` file to dump as a
positional argument rather than the old way of using an option (`actonc dump
--file foo.ty`)
### Fixed
- Avoid segfault in actondb due to uninitialized mon fds [#627] [#633]
- Exceptions during build of executables no longer deletes produced .ty files [#629]
- Fixed DB server & client issues leading to segfaults [#559]
- Pass skiplist keys by reference
- Fix duplicate nonces in msg_callbacks skiplist
- Extend lock protection over msg_callbacks
- DB client no longer asserts & exits on perror [#574]
- Now handles more errors rather than bailing out
- Properly initialize fd_data entries [#571]
- Sometimes a slot wasn't properly initialized, which would lead to incorrect
behavior
- RTS now cleans up and closes fd on EOF [#570]
- RTS fd array is now 1024 slots long [#570]
- Used to be 100, which means we can address up to 100 fds. Default fd limit
on most Linuxes is 1024, so we align on that. The proper fix is to have a
dynamic structure for fd or set it to the same value as the limit (but
that's bad for large values).
- RTS uses sigaction instead of signal, which should tighten up some edge cases
[#587]
- Do not print log message on new connection in RTS / env [#607]
- Correct Debian package dependencies [#625]
- We used the wrong dependencies, shared libraries, when we should have the
development libraries available, since we are not a "normal" application but
a compiler, so when we in turn build programs we want to link them as
statically as possible (sort of, not including libc but most other things)
- Now installing the .deb file will pull in all the correct dependencies on
Debian 11 / bullseye and Ubuntu 20.04
- Correct handling of plain and raw bytes / string literals [#655] [#657]
- UTF-8 encoding is now enforced for source files
- All library dependencies are now included in the Acton [#693]
- For example libuv, libutf8proc, libbsd (on Linux)
- No longer partially linking some modules like math & numpy
- We used to partially link in e.g. libbsd into math
- numpy imports math so importing both math and numpy means we got duplicate
symbols
- This was likely a faulty design in the first place as it lead to symbol
collisions
- Now all library dependencies are part of the Acton distribution and are
linked in with the final application at actonc build time
- Files are stored as e.g. dist/lib/libuv_a.a. The _a suffix is to ensure we
get the statically compiled library and do not link with a shared .so
library if one happens to be present on the system.
- C lib guide rewritten for new .ext.c style [#766][#766]
- Custom make file invocations are now more idempotent [#845]
- Avoid copying .h files which forces make to rebuild targets
### Testing / CI
- Tasty (Haskell test library & runner) is now used for testing actonc. Most
tests have been migrated from test/Makefile to compiler/test.hs [#631]
- Tasty offers different style testing; unit, golden, property etc, with
flexible runners that can execute tests in paralell. Has nice, compact and
colorized output in the terminal and can output to richer formats as well as
run benchmarking tests.
- There are now timeouts for all tests run by Tasty
- TCP servers stress test for opening & closing fds in RTS [#570]
- actonc build of projects have some test cases [#623] [#625]
- Now testing on MacOS 12 [#527]
- Stopped testing on MacOS 10 []
- Now testing on Ubuntu 20.04, 22.04 & 22.10 [#700]
- New test jobs for running actonc and its output on a clean machine [#]
- This installs acton from a .deb file on Linux and from artifact .zip file on
Mac
- Ensure that we have all dependencies declared correctly and that we ship all
necessary files
- Running on same platforms as normal test, i.e.:
- MacOS 11 & 12
- Debian 11
- Ubuntu 20.04, 22.04 & 22.10
## [0.10.0] (2022-02-25)
### Added
- actors now have a `__resume__` function that is called by the RTS just after
actors have been deserialized from the database [#517]
- This is effectively a generic hook point that can be used by certain actor
implementations to run code when being resumed from the database
- ListenSocket supports resumption [#529]
- We cannot restore the previous state of a listening socket since that fd and
all its associated resources in the kernel etc are gone.
- The next best thing we can do is tell the application, through the error
callback, that there is an error with the listen socket and it is then up to
the application to retry, effectively attempting to listen again
- Connection now supports resumption [#546]
- Similar to ListenSocket, so that upon resumption we invoke the registered
error handler so that the application can reconnect
- Unlike ListenSocket, the error callback must first be registered through
`on_receive` on the `Connection`
- What's neat is that any application that attempts to handle reconnects will
also automatically have code for dealing with Acton based actor migration
and recovery!!!
- `actonc` now takes `--tempdir` option to write intermediate output (generated
C) to instead of randomly generated directory, which also means the specified
directory is kept and not deleted on exit [#516]
- in the generated directory, there is a `build.sh` file that contains the
same commands that `actonc` would use to produce the final binary output
from the source files
### Changed
- `on_receipt` is now called `on_receive` on `Connection` [#522]
- `on_connection` is now called `on_connect` on `env.listen` [#535]
- The error callbacks of Connection & ListenSocket now receive the Connection or
ListenSocket as an argument so that it is easy to identify which instance the
error pertains too [#547]
- The main program thread is no longer named `main` [#528]
- The thread name is reported in various tools like top and ps or when there
is no thread name, the process name is used
- The process name is more unique than the main thread name (always "main"),
so we prefer to use the process name
### Fixed
- Initialize `pthread_getspecific` to `NULL` value [#529]
- Avoids segfault, in particular on MacOS
- `on_connect` callback is now always handed a connection argument [#538]
- Every since we split out the error handler this was really the case but the
function signature indicated that it was maybe a Connection and so all
application code had to be written defensively, checking if the argument was
None
- It will never be None and the signature now matches that so application code
can be written more cleanly
- Fix TCP client connection on Linux with epoll [#542]
- Ever since we started supporting epoll natively on Linux, rather than the
libkqueue shim layer, we have had this regression where TCP client
connections do not work
- We registered the same fd with different filters in epoll which resulted in
an error. It's now fixed by first clearing older flags before
re-registering the fd.
- ActonDB and DDB libraries are now compiled with debug flags [#529]
- Unlike other parts of RTS that are compiled with debug flags when `actonc
--dev` is used, we don't have the same possibility of conditional
compilation here, so meanwhile the DDB things will now always include debug
flags
### Testing / CI
- Correct DB test so that the return value is actually inspected [#518]
- Generated files now come with newline [#521]
- Work around current issues with serialization of uninitialized values [#518]
- Remove old RTS DDB test [#530]
## [0.9.1] (2022-02-17)
### Fixed
- Fix ActonDB monitor interface initialization [#514]
- God knows how this ever worked, but it mostly did on Linux. Mac OS X really
exposed the errors together with the RTS not halting on DDB errors, which we
should address through [#431]
- Serialize all manually constructed actors [#512]
- A new convenience function makes it easier to serialize all manually
constructed actors to the DB and it is used in various places so that all
currently known actors are serialized
- The better fix for most of these actors is probably to have CPS converted
init functions instead but that's some more code to write which is
cumbersome for manually defined actors
## [0.9.0] (2022-02-15)
### Added
- Add DB client library statistics [#473]
- We keep count, sum of time and timing buckets per operation type
- `actonmon` exposes these metrics over the prometheus HTTP endpoint
- RTS mon interface now uses netstrings as line encoding [#494]
- Much more robust than the previous implementation which relied on luck
- netstrings are very simple and can be implemented in a few lines of C or
Python, so we are still considerably simpler than protobuf or similar
- Add mon interface to ActonDB [#499]
- We only expose membership information
- Gives us a nice programmatic interface to query the DB for membership info,
so we can determine whether our DB cluster has converged or not
- Acton RTS now handles `SIGINT` and `SIGTERM` [#509]
- RTS will gracefully shutdown upon receiving
gitextract_p92zbpa_/
├── .containerignore
├── .github/
│ ├── ISSUE_TEMPLATE/
│ │ ├── blank_issue.md
│ │ ├── bug.yaml
│ │ ├── config.yml
│ │ ├── feature.yaml
│ │ └── ice.yaml
│ ├── dependabot.yml
│ └── workflows/
│ ├── claude.yml
│ ├── code-agent.yml
│ ├── create-release.yml
│ ├── release.yml
│ ├── test-app.yml
│ ├── test.yml
│ ├── trigger-web-update.yml
│ ├── update-ask-acton-vector-store.yml
│ └── webex-notifications.yml
├── .gitignore
├── .gitmodules
├── AGENTS.md
├── CHANGELOG.md
├── CLAUDE.md
├── CONTRIBUTING.md
├── Containerfile
├── Containerfile.deb
├── LICENSE
├── Makefile
├── README.md
├── backend/
│ ├── .gitignore
│ ├── Build.act
│ ├── CLAUDE.md
│ ├── actondb.c
│ ├── client_api.c
│ ├── client_api.h
│ ├── comm.c
│ ├── comm.h
│ ├── common.h
│ ├── consumer_state.h
│ ├── db.c
│ ├── db.h
│ ├── db_client_api.h
│ ├── failure_detector/
│ │ ├── cells.c
│ │ ├── cells.h
│ │ ├── db_messages.pb-c.c
│ │ ├── db_messages.pb-c.h
│ │ ├── db_messages.proto
│ │ ├── db_messages_test.c
│ │ ├── db_queries.c
│ │ ├── db_queries.h
│ │ ├── fd.c
│ │ ├── fd.h
│ │ ├── txns.h
│ │ ├── vector_clock.c
│ │ └── vector_clock.h
│ ├── fastrand.h
│ ├── hash_ring.c
│ ├── hash_ring.h
│ ├── hashes.h
│ ├── log.c
│ ├── log.h
│ ├── queue.c
│ ├── queue.h
│ ├── queue_callback.c
│ ├── queue_callback.h
│ ├── queue_groups.c
│ ├── queue_groups.h
│ ├── skiplist.c
│ ├── skiplist.h
│ ├── test/
│ │ ├── actor_ring_tests_local.c
│ │ ├── actor_ring_tests_remote.c
│ │ ├── db_unit_tests.c
│ │ ├── queue_unit_tests.c
│ │ ├── skiplist_test.c
│ │ └── test_client.c
│ ├── txn_state.c
│ ├── txn_state.h
│ ├── txns.c
│ └── txns.h
├── base/
│ ├── .gitignore
│ ├── Build.act
│ ├── CLAUDE.md
│ ├── __root.zig
│ ├── acton.zig
│ ├── builtin/
│ │ ├── Iterator.c
│ │ ├── Iterator.h
│ │ ├── atom.c
│ │ ├── atom.h
│ │ ├── bigint.c
│ │ ├── bigint.h
│ │ ├── bool.c
│ │ ├── bool.h
│ │ ├── box.c
│ │ ├── box.h
│ │ ├── builtin.c
│ │ ├── builtin.h
│ │ ├── builtin_functions.c
│ │ ├── builtin_functions.h
│ │ ├── class_hierarchy.c
│ │ ├── class_hierarchy.h
│ │ ├── common.c
│ │ ├── common.h
│ │ ├── complex.c
│ │ ├── complx.h
│ │ ├── csiphash.c
│ │ ├── dict.c
│ │ ├── dict.h
│ │ ├── env.c
│ │ ├── env.h
│ │ ├── exceptions.c
│ │ ├── exceptions.h
│ │ ├── float.c
│ │ ├── float.h
│ │ ├── function.c
│ │ ├── function.h
│ │ ├── hasher.c
│ │ ├── hasher.h
│ │ ├── i16.c
│ │ ├── i16.h
│ │ ├── i32.c
│ │ ├── i32.h
│ │ ├── i8.c
│ │ ├── i8.h
│ │ ├── int.c
│ │ ├── int.h
│ │ ├── list.c
│ │ ├── list.h
│ │ ├── none.c
│ │ ├── none.h
│ │ ├── range.c
│ │ ├── range.h
│ │ ├── registration.c
│ │ ├── registration.h
│ │ ├── serialize.c
│ │ ├── serialize.h
│ │ ├── set.c
│ │ ├── set.h
│ │ ├── slice.c
│ │ ├── slice.h
│ │ ├── staticWitnesses.c
│ │ ├── staticWitnesses.h
│ │ ├── str.c
│ │ ├── str.h
│ │ ├── timsort.c
│ │ ├── tuple.c
│ │ ├── tuple.h
│ │ ├── u1.c
│ │ ├── u1.h
│ │ ├── u16.c
│ │ ├── u16.h
│ │ ├── u32.c
│ │ ├── u32.h
│ │ ├── u64.c
│ │ ├── u64.h
│ │ ├── u8.c
│ │ ├── u8.h
│ │ ├── utils.c
│ │ └── utils.h
│ ├── rts/
│ │ ├── common.c
│ │ ├── common.h
│ │ ├── gc.zig
│ │ ├── io.c
│ │ ├── io.h
│ │ ├── log.c
│ │ ├── log.h
│ │ ├── netstring.c
│ │ ├── netstring.h
│ │ ├── q.c
│ │ ├── q.h
│ │ ├── rts.c
│ │ └── rts.h
│ └── src/
│ ├── __builtin__.act
│ ├── __builtin__.ext.c
│ ├── acton/
│ │ ├── rts.act
│ │ └── rts.ext.c
│ ├── argparse.act
│ ├── base64.act
│ ├── base64.ext.c
│ ├── buildy.act
│ ├── crypto/
│ │ └── hash/
│ │ ├── md5.act
│ │ └── md5.ext.c
│ ├── diff.act
│ ├── file.act
│ ├── file.ext.c
│ ├── fs.act
│ ├── hash/
│ │ ├── wyhash.act
│ │ └── wyhash.ext.c
│ ├── http.act
│ ├── json.act
│ ├── json.ext.c
│ ├── logging.act
│ ├── logging.ext.c
│ ├── math.act
│ ├── math.ext.c
│ ├── net.act
│ ├── net.ext.c
│ ├── process.act
│ ├── process.ext.c
│ ├── qcheck.act
│ ├── random.act
│ ├── random.ext.c
│ ├── re.act
│ ├── re.ext.c
│ ├── snappy.act
│ ├── snappy.ext.c
│ ├── term.act
│ ├── testing.act
│ ├── time.act
│ ├── time.ext.c
│ ├── uri.act
│ ├── xml.act
│ └── xml.ext.c
├── bin/
│ └── runacton
├── compiler/
│ ├── .gitignore
│ ├── CLAUDE.md
│ ├── acton/
│ │ ├── Main.hs
│ │ ├── PkgCommands.hs
│ │ ├── TerminalProgress.hs
│ │ ├── TerminalSize.hs
│ │ ├── TestFormat.hs
│ │ ├── TestGolden.hs
│ │ ├── TestRunner.hs
│ │ ├── TestUI.hs
│ │ ├── ZigProgress.hs
│ │ ├── package.yaml.in
│ │ ├── test/
│ │ │ ├── incremental_cases/
│ │ │ │ └── .gitignore
│ │ │ ├── parse/
│ │ │ │ ├── simple.act
│ │ │ │ ├── simple.all.golden
│ │ │ │ ├── simple.box.golden
│ │ │ │ ├── simple.cgen.golden
│ │ │ │ ├── simple.cps.golden
│ │ │ │ ├── simple.deact.golden
│ │ │ │ ├── simple.golden
│ │ │ │ ├── simple.hgen.golden
│ │ │ │ ├── simple.kinds.golden
│ │ │ │ ├── simple.llift.golden
│ │ │ │ ├── simple.norm.golden
│ │ │ │ ├── simple.sigs.golden
│ │ │ │ └── simple.types.golden
│ │ │ ├── project/
│ │ │ │ ├── auto_root/
│ │ │ │ │ ├── .gitignore
│ │ │ │ │ ├── Build.act
│ │ │ │ │ └── src/
│ │ │ │ │ ├── b.act
│ │ │ │ │ └── test.act
│ │ │ │ ├── conf_2bin/
│ │ │ │ │ ├── .gitignore
│ │ │ │ │ ├── Build.act
│ │ │ │ │ └── src/
│ │ │ │ │ ├── a.act
│ │ │ │ │ └── b.act
│ │ │ │ ├── missing_src/
│ │ │ │ │ ├── .gitignore
│ │ │ │ │ └── Build.act
│ │ │ │ ├── prune_executables/
│ │ │ │ │ ├── .gitignore
│ │ │ │ │ ├── Build.act
│ │ │ │ │ └── src/
│ │ │ │ │ ├── bar.act
│ │ │ │ │ ├── foo.act
│ │ │ │ │ └── tests/
│ │ │ │ │ └── simple.act
│ │ │ │ ├── prune_partials/
│ │ │ │ │ ├── .gitignore
│ │ │ │ │ ├── Build.act
│ │ │ │ │ └── src/
│ │ │ │ │ ├── bar.act
│ │ │ │ │ └── foo.act
│ │ │ │ ├── prune_roots/
│ │ │ │ │ ├── .gitignore
│ │ │ │ │ ├── Build.act
│ │ │ │ │ └── src/
│ │ │ │ │ └── foo.act
│ │ │ │ ├── qualified_root/
│ │ │ │ │ ├── .gitignore
│ │ │ │ │ ├── Build.act
│ │ │ │ │ └── src/
│ │ │ │ │ ├── b.act
│ │ │ │ │ └── test.act
│ │ │ │ └── simple/
│ │ │ │ ├── .gitignore
│ │ │ │ ├── Build.act
│ │ │ │ └── src/
│ │ │ │ ├── a.act
│ │ │ │ └── b.act
│ │ │ ├── rebuild/
│ │ │ │ ├── .gitignore
│ │ │ │ ├── Build.act
│ │ │ │ └── golden/
│ │ │ │ ├── file_02-initial-build.golden
│ │ │ │ ├── file_03-up-to-date.golden
│ │ │ │ ├── file_04-touch-no-rebuild.golden
│ │ │ │ ├── file_06-change-a-impl.golden
│ │ │ │ ├── file_08-change-b-impl.golden
│ │ │ │ ├── project_02-initial-build.golden
│ │ │ │ ├── project_03-up-to-date.golden
│ │ │ │ ├── project_04-touch-no-rebuild.golden
│ │ │ │ ├── project_06-change-a-impl.golden
│ │ │ │ ├── project_08-change-b-impl.golden
│ │ │ │ ├── project_10-change-a-iface.golden
│ │ │ │ ├── project_11-change-b-doc.golden
│ │ │ │ └── project_12-codegen-stale.golden
│ │ │ ├── root/
│ │ │ │ └── test.act
│ │ │ ├── syntaxerrors/
│ │ │ │ ├── err1.act
│ │ │ │ ├── err1.golden
│ │ │ │ ├── err10.act
│ │ │ │ ├── err10.golden
│ │ │ │ ├── err11.act
│ │ │ │ ├── err11.golden
│ │ │ │ ├── err12.act
│ │ │ │ ├── err12.golden
│ │ │ │ ├── err13.act
│ │ │ │ ├── err13.golden
│ │ │ │ ├── err14.act
│ │ │ │ ├── err14.golden
│ │ │ │ ├── err15.act
│ │ │ │ ├── err15.golden
│ │ │ │ ├── err16.act
│ │ │ │ ├── err16.golden
│ │ │ │ ├── err17.act
│ │ │ │ ├── err17.golden
│ │ │ │ ├── err18.act
│ │ │ │ ├── err18.golden
│ │ │ │ ├── err19.act
│ │ │ │ ├── err19.golden
│ │ │ │ ├── err2.act
│ │ │ │ ├── err2.golden
│ │ │ │ ├── err20.act
│ │ │ │ ├── err20.golden
│ │ │ │ ├── err21.act
│ │ │ │ ├── err21.golden
│ │ │ │ ├── err22.act
│ │ │ │ ├── err22.golden
│ │ │ │ ├── err23.act
│ │ │ │ ├── err23.golden
│ │ │ │ ├── err24.act
│ │ │ │ ├── err24.golden
│ │ │ │ ├── err25.act
│ │ │ │ ├── err25.golden
│ │ │ │ ├── err26.act
│ │ │ │ ├── err26.golden
│ │ │ │ ├── err27.act
│ │ │ │ ├── err27.golden
│ │ │ │ ├── err28.act
│ │ │ │ ├── err28.golden
│ │ │ │ ├── err29.act
│ │ │ │ ├── err29.golden
│ │ │ │ ├── err3.act
│ │ │ │ ├── err3.golden
│ │ │ │ ├── err30.act
│ │ │ │ ├── err30.golden
│ │ │ │ ├── err31.act
│ │ │ │ ├── err31.golden
│ │ │ │ ├── err32.act
│ │ │ │ ├── err32.golden
│ │ │ │ ├── err33.act
│ │ │ │ ├── err33.golden
│ │ │ │ ├── err34.act
│ │ │ │ ├── err34.golden
│ │ │ │ ├── err35.act
│ │ │ │ ├── err35.golden
│ │ │ │ ├── err36.act
│ │ │ │ ├── err36.golden
│ │ │ │ ├── err37.act
│ │ │ │ ├── err37.golden
│ │ │ │ ├── err38.act
│ │ │ │ ├── err38.golden
│ │ │ │ ├── err39.act
│ │ │ │ ├── err39.golden
│ │ │ │ ├── err4.act
│ │ │ │ ├── err4.golden
│ │ │ │ ├── err40.act
│ │ │ │ ├── err40.golden
│ │ │ │ ├── err41.act
│ │ │ │ ├── err41.golden
│ │ │ │ ├── err42.act
│ │ │ │ ├── err42.golden
│ │ │ │ ├── err5.act
│ │ │ │ ├── err5.golden
│ │ │ │ ├── err6.act
│ │ │ │ ├── err6.golden
│ │ │ │ ├── err7.act
│ │ │ │ ├── err7.golden
│ │ │ │ ├── err8.act
│ │ │ │ ├── err8.golden
│ │ │ │ ├── err9.act
│ │ │ │ └── err9.golden
│ │ │ └── typeerrors/
│ │ │ ├── actor_self_reserved_assignment.act
│ │ │ ├── actor_self_reserved_assignment.golden
│ │ │ ├── actor_self_reserved_constructor_param.act
│ │ │ ├── actor_self_reserved_constructor_param.golden
│ │ │ ├── actor_self_reserved_except_as.act
│ │ │ ├── actor_self_reserved_except_as.golden
│ │ │ ├── actor_self_reserved_loop_var.act
│ │ │ ├── actor_self_reserved_loop_var.golden
│ │ │ ├── actor_self_reserved_method_name.act
│ │ │ ├── actor_self_reserved_method_name.golden
│ │ │ ├── actor_self_reserved_method_param.act
│ │ │ ├── actor_self_reserved_method_param.golden
│ │ │ ├── actor_self_reserved_method_param2.act
│ │ │ ├── actor_self_reserved_method_param2.golden
│ │ │ ├── actor_self_reserved_variable.act
│ │ │ ├── actor_self_reserved_variable.golden
│ │ │ ├── ex1.act
│ │ │ ├── ex1.golden
│ │ │ ├── ex10.act
│ │ │ ├── ex10.golden
│ │ │ ├── ex11.act
│ │ │ ├── ex11.golden
│ │ │ ├── ex13.act
│ │ │ ├── ex13.golden
│ │ │ ├── ex14.act
│ │ │ ├── ex14.golden
│ │ │ ├── ex15.act
│ │ │ ├── ex15.golden
│ │ │ ├── ex16.act
│ │ │ ├── ex16.golden
│ │ │ ├── ex17.act
│ │ │ ├── ex17.golden
│ │ │ ├── ex18.act
│ │ │ ├── ex18.golden
│ │ │ ├── ex19.act
│ │ │ ├── ex19.golden
│ │ │ ├── ex2.act
│ │ │ ├── ex2.golden
│ │ │ ├── ex20.act
│ │ │ ├── ex20.golden
│ │ │ ├── ex21.act
│ │ │ ├── ex21.golden
│ │ │ ├── ex22.act
│ │ │ ├── ex22.golden
│ │ │ ├── ex23.act
│ │ │ ├── ex23.golden
│ │ │ ├── ex24.act
│ │ │ ├── ex24.golden
│ │ │ ├── ex25.act
│ │ │ ├── ex25.golden
│ │ │ ├── ex26.act
│ │ │ ├── ex26.golden
│ │ │ ├── ex27.act
│ │ │ ├── ex27.golden
│ │ │ ├── ex4.act
│ │ │ ├── ex4.golden
│ │ │ ├── ex5.act
│ │ │ ├── ex5.golden
│ │ │ ├── ex6.act
│ │ │ ├── ex6.golden
│ │ │ ├── ex7.act
│ │ │ ├── ex7.golden
│ │ │ ├── ex8.act
│ │ │ ├── ex8.golden
│ │ │ ├── ex9.act
│ │ │ ├── ex9.golden
│ │ │ ├── funargs1.act
│ │ │ ├── funargs1.golden
│ │ │ ├── funargs2.act
│ │ │ ├── funargs2.golden
│ │ │ ├── funargs3.act
│ │ │ ├── funargs3.golden
│ │ │ ├── funargs4.act
│ │ │ ├── funargs4.golden
│ │ │ ├── funargs5.act
│ │ │ ├── funargs5.golden
│ │ │ ├── funargs6.act
│ │ │ └── funargs6.golden
│ │ ├── test.hs
│ │ ├── test_incremental.hs
│ │ └── test_online.hs
│ ├── diagnose/
│ │ ├── .gitignore
│ │ ├── LICENSE
│ │ ├── PATCHES.md
│ │ ├── README.md
│ │ ├── diagnose.cabal
│ │ ├── hie.yaml
│ │ ├── nix/
│ │ │ ├── nixpkgs-pinned.nix
│ │ │ └── stack.nix
│ │ ├── package.yaml
│ │ ├── src/
│ │ │ ├── Data/
│ │ │ │ └── List/
│ │ │ │ └── Safe.hs
│ │ │ └── Error/
│ │ │ ├── Diagnose/
│ │ │ │ ├── Compat/
│ │ │ │ │ ├── Hints.hs
│ │ │ │ │ ├── Megaparsec.hs
│ │ │ │ │ └── Parsec.hs
│ │ │ │ ├── Diagnostic/
│ │ │ │ │ └── Internal.hs
│ │ │ │ ├── Diagnostic.hs
│ │ │ │ ├── Position.hs
│ │ │ │ ├── Pretty.hs
│ │ │ │ ├── Report/
│ │ │ │ │ └── Internal.hs
│ │ │ │ ├── Report.hs
│ │ │ │ └── Style.hs
│ │ │ └── Diagnose.hs
│ │ ├── stack.yaml
│ │ └── test/
│ │ ├── megaparsec/
│ │ │ ├── Instances.hs
│ │ │ ├── Repro6.hs
│ │ │ └── Spec.hs
│ │ ├── parsec/
│ │ │ ├── Repro2.hs
│ │ │ └── Spec.hs
│ │ └── rendering/
│ │ └── Spec.hs
│ ├── lib/
│ │ ├── bench/
│ │ │ ├── KindsBench.hs
│ │ │ └── TypesBench.hs
│ │ ├── package.yaml.in
│ │ ├── src/
│ │ │ ├── Acton/
│ │ │ │ ├── Boxing.hs
│ │ │ │ ├── BuildSpec.hs
│ │ │ │ ├── Builtin.hs
│ │ │ │ ├── CPS.hs
│ │ │ │ ├── CodeGen.hs
│ │ │ │ ├── CommandLineParser.hs
│ │ │ │ ├── Compile.hs
│ │ │ │ ├── Completion.hs
│ │ │ │ ├── Converter.hs
│ │ │ │ ├── Deactorizer.hs
│ │ │ │ ├── Diagnostics.hs
│ │ │ │ ├── DocPrinter.hs
│ │ │ │ ├── Env.hs
│ │ │ │ ├── Fingerprint.hs
│ │ │ │ ├── Hashing.hs
│ │ │ │ ├── Kinds.hs
│ │ │ │ ├── LambdaLifter.hs
│ │ │ │ ├── NameInfo.hs
│ │ │ │ ├── Names.hs
│ │ │ │ ├── Normalizer.hs
│ │ │ │ ├── Parser.hs
│ │ │ │ ├── Prim.hs
│ │ │ │ ├── Printer.hs
│ │ │ │ ├── QuickType.hs
│ │ │ │ ├── Solver.hs
│ │ │ │ ├── SourceProvider.hs
│ │ │ │ ├── Subst.hs
│ │ │ │ ├── Syntax.hs
│ │ │ │ ├── Testing.hs
│ │ │ │ ├── Transform.hs
│ │ │ │ ├── TypeEnv.hs
│ │ │ │ ├── Types.hs
│ │ │ │ └── WitKnots.hs
│ │ │ ├── InterfaceFiles.hs
│ │ │ ├── Pretty.hs
│ │ │ ├── SrcLocation.hs
│ │ │ ├── Text_Megaparsec_Expr.hs
│ │ │ └── Utils.hs
│ │ └── test/
│ │ ├── 1-parse/
│ │ │ ├── docstrings.input
│ │ │ ├── docstrings.output
│ │ │ ├── syntax1.input
│ │ │ └── syntax1.output
│ │ ├── 2-kinds/
│ │ │ ├── deact.input
│ │ │ └── deact.output
│ │ ├── 3-types/
│ │ │ ├── class_init_attrs/
│ │ │ │ ├── uninit_assert_uninit_attr.golden
│ │ │ │ ├── uninit_augmented_assign.golden
│ │ │ │ ├── uninit_basic.golden
│ │ │ │ ├── uninit_basic_inferred.golden
│ │ │ │ ├── uninit_elif_missing.golden
│ │ │ │ ├── uninit_for_loop.golden
│ │ │ │ ├── uninit_grandparent.golden
│ │ │ │ ├── uninit_grandparent2.golden
│ │ │ │ ├── uninit_inherited.golden
│ │ │ │ ├── uninit_init_in_method.golden
│ │ │ │ ├── uninit_loop_references_self.golden
│ │ │ │ ├── uninit_method_call.golden
│ │ │ │ ├── uninit_method_call_assign.golden
│ │ │ │ ├── uninit_method_reference.golden
│ │ │ │ ├── uninit_nested_function_escape.golden
│ │ │ │ ├── uninit_nested_function_with_self.golden
│ │ │ │ ├── uninit_nested_if.golden
│ │ │ │ ├── uninit_no_parent_init.golden
│ │ │ │ ├── uninit_notimpl_call_other.golden
│ │ │ │ ├── uninit_partial.golden
│ │ │ │ ├── uninit_return_early.golden
│ │ │ │ ├── uninit_self_attr_access.golden
│ │ │ │ ├── uninit_self_in_list.golden
│ │ │ │ ├── uninit_self_reference.golden
│ │ │ │ └── uninit_try_except.golden
│ │ │ ├── deact.input
│ │ │ ├── deact.output
│ │ │ ├── test_discovery.input
│ │ │ └── test_discovery.output
│ │ ├── 4-normalizer/
│ │ │ ├── deact.input
│ │ │ └── deact.output
│ │ ├── 5-deactorizer/
│ │ │ ├── deact.input
│ │ │ ├── deact.output
│ │ │ ├── deact_from_import.input
│ │ │ └── deact_from_import.output
│ │ ├── 6-cps/
│ │ │ ├── cps_andor.input
│ │ │ ├── cps_andor.output
│ │ │ ├── cps_optchain.input
│ │ │ ├── cps_optchain.output
│ │ │ ├── cps_volatiles.input
│ │ │ └── cps_volatiles.output
│ │ ├── 7-lambdalifting/
│ │ │ ├── deact.input
│ │ │ └── deact.output
│ │ ├── 8-boxing/
│ │ │ ├── deact.input
│ │ │ └── deact.output
│ │ ├── 9-codegen/
│ │ │ ├── deact.c
│ │ │ ├── deact.h
│ │ │ ├── deact.input
│ │ │ ├── ints.c
│ │ │ ├── ints.h
│ │ │ ├── ints.input
│ │ │ ├── lines.c
│ │ │ ├── lines.h
│ │ │ └── lines.input
│ │ ├── ActonSpec.hs
│ │ ├── doc-golden/
│ │ │ ├── bar-color.txt
│ │ │ ├── bar.html
│ │ │ ├── bar.md
│ │ │ ├── bar.txt
│ │ │ ├── foo-color.txt
│ │ │ ├── foo.html
│ │ │ ├── foo.md
│ │ │ └── foo.txt
│ │ ├── parser_golden/
│ │ │ ├── alternating_quotes_error.golden
│ │ │ ├── deep_nesting_error.golden
│ │ │ ├── error_at_end.golden
│ │ │ ├── error_at_start.golden
│ │ │ ├── error_in_middle.golden
│ │ │ ├── escaped_brace_error.golden
│ │ │ ├── fstring_empty_expression.golden
│ │ │ ├── fstring_empty_format_specifier.golden
│ │ │ ├── fstring_invalid_alignment.golden
│ │ │ ├── fstring_invalid_format.golden
│ │ │ ├── fstring_missing_expression.golden
│ │ │ ├── fstring_missing_precision_digits_error.golden
│ │ │ ├── fstring_triple_double_6quotes.golden
│ │ │ ├── fstring_triple_single_6quotes.golden
│ │ │ ├── fstring_unbalanced_format.golden
│ │ │ ├── fstring_unclosed_brace.golden
│ │ │ ├── hex_incomplete_in_interpolation.golden
│ │ │ ├── hex_incomplete_no_digits.golden
│ │ │ ├── hex_incomplete_one_digit.golden
│ │ │ ├── hex_invalid_char.golden
│ │ │ ├── invalid_after_align.golden
│ │ │ ├── invalid_after_precision.golden
│ │ │ ├── invalid_after_width.golden
│ │ │ ├── invalid_in_type_spec.golden
│ │ │ ├── mixed_quotes_unclosed.golden
│ │ │ ├── mixed_six_quotes_double.golden
│ │ │ ├── module_actor_before_import.golden
│ │ │ ├── module_call_before_import.golden
│ │ │ ├── module_class_before_import.golden
│ │ │ ├── module_dict_before_import.golden
│ │ │ ├── module_for_before_import.golden
│ │ │ ├── module_func_before_import.golden
│ │ │ ├── module_if_before_import.golden
│ │ │ ├── module_list_before_import.golden
│ │ │ ├── module_number_before_import.golden
│ │ │ ├── module_var_before_import.golden
│ │ │ ├── multiline_format_error.golden
│ │ │ ├── multiline_nested_error.golden
│ │ │ ├── multiline_unclosed.golden
│ │ │ ├── nested_bad_type_spec.golden
│ │ │ ├── nested_empty_format.golden
│ │ │ ├── nested_empty_inner.golden
│ │ │ ├── nested_invalid_align.golden
│ │ │ ├── nested_invalid_format.golden
│ │ │ ├── nested_unclosed_inner.golden
│ │ │ ├── nested_unclosed_outer.golden
│ │ │ ├── newline_in_expr.golden
│ │ │ ├── octal_invalid_char.golden
│ │ │ ├── octal_invalid_first_digit.golden
│ │ │ ├── octal_out_of_range.golden
│ │ │ ├── octal_out_of_range_in_fstring.golden
│ │ │ ├── raw_six_quotes.golden
│ │ │ ├── raw_triple_double_6quotes.golden
│ │ │ ├── raw_triple_single_6quotes.golden
│ │ │ ├── seven_double_quotes.golden
│ │ │ ├── six_double_quotes.golden
│ │ │ ├── six_single_quotes.golden
│ │ │ ├── slice_format_error.golden
│ │ │ ├── slice_invalid_step.golden
│ │ │ ├── slice_missing_bracket.golden
│ │ │ ├── slice_nested_error.golden
│ │ │ ├── slice_unclosed_bracket.golden
│ │ │ ├── string_empty_expression.golden
│ │ │ ├── string_invalid_format.golden
│ │ │ ├── string_missing_expression.golden
│ │ │ ├── string_unclosed_brace.golden
│ │ │ ├── tab_in_format.golden
│ │ │ ├── triple_double_10quotes.golden
│ │ │ ├── triple_double_6quotes.golden
│ │ │ ├── triple_double_7quotes.golden
│ │ │ ├── triple_double_8quotes.golden
│ │ │ ├── triple_nested_unclosed.golden
│ │ │ ├── triple_single_10quotes.golden
│ │ │ ├── triple_single_6quotes.golden
│ │ │ ├── triple_single_7quotes.golden
│ │ │ ├── triple_single_8quotes.golden
│ │ │ ├── tristring_unclosed_brace.golden
│ │ │ ├── unclosed_bytes_string.golden
│ │ │ ├── unclosed_bytes_string_single.golden
│ │ │ ├── unclosed_raw_bytes_string.golden
│ │ │ ├── unclosed_raw_bytes_string_single.golden
│ │ │ ├── unclosed_raw_string.golden
│ │ │ ├── unclosed_raw_string_single.golden
│ │ │ ├── unclosed_string.golden
│ │ │ ├── unclosed_string_triple.golden
│ │ │ ├── unicode_format_error.golden
│ │ │ ├── unicode_long_in_fstring.golden
│ │ │ ├── unicode_long_incomplete.golden
│ │ │ ├── unicode_long_invalid_char.golden
│ │ │ ├── unicode_long_no_digits.golden
│ │ │ ├── unicode_short_in_fstring.golden
│ │ │ ├── unicode_short_incomplete.golden
│ │ │ ├── unicode_short_invalid_char.golden
│ │ │ ├── unicode_short_no_digits.golden
│ │ │ ├── unknown_escape_in_fstring.golden
│ │ │ ├── unknown_escape_p.golden
│ │ │ ├── unknown_escape_with_interpolation.golden
│ │ │ └── unknown_escape_z.golden
│ │ └── src/
│ │ ├── bar.act
│ │ ├── class_init_attrs/
│ │ │ ├── init_actor.act
│ │ │ ├── init_actor_call.act
│ │ │ ├── init_after_loop.act
│ │ │ ├── init_after_statements.act
│ │ │ ├── init_after_while.act
│ │ │ ├── init_assert.act
│ │ │ ├── init_assert_with_self.act
│ │ │ ├── init_basic.act
│ │ │ ├── init_both_branches_with_raise.act
│ │ │ ├── init_conditional.act
│ │ │ ├── init_constant_condition.act
│ │ │ ├── init_delete.act
│ │ │ ├── init_elif_raise_after_assignment.act
│ │ │ ├── init_except_raise_after_assignment.act
│ │ │ ├── init_function_call.act
│ │ │ ├── init_grandparent_call.act
│ │ │ ├── init_inferred_only.act
│ │ │ ├── init_inherited.act
│ │ │ ├── init_loop_break.act
│ │ │ ├── init_loop_continue.act
│ │ │ ├── init_mixed_parent_self.act
│ │ │ ├── init_multiple.act
│ │ │ ├── init_multiple_except_handlers.act
│ │ │ ├── init_nested_function.act
│ │ │ ├── init_nested_function_call.act
│ │ │ ├── init_nested_if.act
│ │ │ ├── init_nested_if_raise.act
│ │ │ ├── init_no_init_uses_parent.act
│ │ │ ├── init_notimpl_call.act
│ │ │ ├── init_notimplemented.act
│ │ │ ├── init_parent_call.act
│ │ │ ├── init_raise_after_assignment.act
│ │ │ ├── init_self_attr_access.act
│ │ │ ├── init_self_attr_conditional.act
│ │ │ ├── init_self_attr_in_expr.act
│ │ │ ├── init_self_attr_in_loop.act
│ │ │ ├── init_self_attr_reference.act
│ │ │ ├── init_try_else_combined.act
│ │ │ ├── init_try_except.act
│ │ │ ├── init_try_except_finally.act
│ │ │ ├── init_try_except_raise.act
│ │ │ ├── init_try_finally.act
│ │ │ ├── init_try_inside_if.act
│ │ │ ├── uninit_assert_uninit_attr.act
│ │ │ ├── uninit_augmented_assign.act
│ │ │ ├── uninit_basic.act
│ │ │ ├── uninit_basic_inferred.act
│ │ │ ├── uninit_elif_missing.act
│ │ │ ├── uninit_for_loop.act
│ │ │ ├── uninit_grandparent.act
│ │ │ ├── uninit_grandparent2.act
│ │ │ ├── uninit_inherited.act
│ │ │ ├── uninit_init_in_method.act
│ │ │ ├── uninit_loop_references_self.act
│ │ │ ├── uninit_method_call.act
│ │ │ ├── uninit_method_call_assign.act
│ │ │ ├── uninit_method_reference.act
│ │ │ ├── uninit_nested_function_escape.act
│ │ │ ├── uninit_nested_function_with_self.act
│ │ │ ├── uninit_nested_if.act
│ │ │ ├── uninit_no_parent_init.act
│ │ │ ├── uninit_notimpl_call_other.act
│ │ │ ├── uninit_partial.act
│ │ │ ├── uninit_return_early.act
│ │ │ ├── uninit_self_attr_access.act
│ │ │ ├── uninit_self_in_list.act
│ │ │ ├── uninit_self_reference.act
│ │ │ └── uninit_try_except.act
│ │ ├── cps_andor.act
│ │ ├── cps_optchain.act
│ │ ├── cps_volatiles.act
│ │ ├── deact.act
│ │ ├── deact_from_import.act
│ │ ├── docstrings.act
│ │ ├── foo.act
│ │ ├── import_private.act
│ │ ├── import_private_a.act
│ │ ├── import_private_qualified.act
│ │ ├── ints.act
│ │ ├── lines.act
│ │ ├── syntax1.act
│ │ └── test_discovery.act
│ ├── lsp-server/
│ │ ├── Main.hs
│ │ └── package.yaml.in
│ ├── stack.yaml
│ ├── test/
│ │ └── .gitignore
│ ├── tests/
│ │ ├── Acton.hs
│ │ ├── ActonLevels.hs
│ │ ├── CPretty.hs
│ │ ├── ProtExtElim.hs
│ │ ├── TestTransform.hs
│ │ ├── actorring.act
│ │ ├── controller.act
│ │ ├── counter.act
│ │ ├── env.act
│ │ ├── env.c
│ │ ├── netconf.act
│ │ ├── newtuple.act
│ │ ├── pingpong.act
│ │ ├── records.act
│ │ ├── test.act
│ │ ├── test1.act
│ │ ├── test2.act
│ │ ├── test3.act
│ │ ├── test4.act
│ │ ├── test5.act
│ │ ├── test6.act
│ │ └── tuples.act
│ └── tools/
│ ├── ld-wrapper.sh
│ ├── zig-cc.sh
│ └── zig-cxx.sh
├── completion/
│ └── acton.bash-completion
├── debian/
│ ├── acton.bash-completion
│ ├── changelog.in
│ ├── control
│ ├── copyright
│ ├── rules
│ └── watch
├── docs/
│ ├── acton-dev-guide/
│ │ ├── .gitignore
│ │ ├── README.md
│ │ ├── book.toml
│ │ ├── mdbook-admonish.css
│ │ ├── src/
│ │ │ ├── SUMMARY.md
│ │ │ ├── builtins/
│ │ │ │ ├── ffi.md
│ │ │ │ ├── functions.md
│ │ │ │ ├── index.md
│ │ │ │ └── types.md
│ │ │ ├── compiler/
│ │ │ │ ├── imports_and_envs.md
│ │ │ │ ├── incremental_compilation.md
│ │ │ │ ├── index.md
│ │ │ │ ├── passes/
│ │ │ │ │ ├── boxing.md
│ │ │ │ │ ├── codegen.md
│ │ │ │ │ ├── cps.md
│ │ │ │ │ ├── deactorize.md
│ │ │ │ │ ├── index.md
│ │ │ │ │ ├── kinds.md
│ │ │ │ │ ├── lambda_lift.md
│ │ │ │ │ ├── normalize.md
│ │ │ │ │ ├── parse.md
│ │ │ │ │ └── type_check.md
│ │ │ │ ├── project_dependencies.md
│ │ │ │ └── test_cache.md
│ │ │ ├── design/
│ │ │ │ ├── capabilities.md
│ │ │ │ ├── concurrency.md
│ │ │ │ └── index.md
│ │ │ ├── getting_started/
│ │ │ │ ├── build.md
│ │ │ │ ├── debugging.md
│ │ │ │ ├── repo_layout.md
│ │ │ │ └── tests.md
│ │ │ ├── getting_started.md
│ │ │ ├── index.md
│ │ │ ├── runtime/
│ │ │ │ ├── actors.md
│ │ │ │ ├── index.md
│ │ │ │ ├── memory.md
│ │ │ │ └── scheduler.md
│ │ │ └── tooling/
│ │ │ ├── index.md
│ │ │ └── testing.md
│ │ ├── svgbob.css
│ │ └── theme/
│ │ ├── content-width.css
│ │ ├── sbscode.css
│ │ ├── sbscode_copy.js
│ │ ├── skill-slider.css
│ │ ├── skill-slider.js
│ │ ├── tabs.css
│ │ └── tabs.js
│ ├── acton-guide/
│ │ ├── .gitignore
│ │ ├── LANGUAGE_REVIEW.md
│ │ ├── README.md
│ │ ├── RUST_BOOK_COMPARISON.md
│ │ ├── book.toml
│ │ ├── mdbook-admonish.css
│ │ ├── src/
│ │ │ ├── SUMMARY.md
│ │ │ ├── actors/
│ │ │ │ ├── async_method_call.md
│ │ │ │ ├── attributes.md
│ │ │ │ ├── cleanup.md
│ │ │ │ ├── concurrency.md
│ │ │ │ ├── lifetime.md
│ │ │ │ ├── root.md
│ │ │ │ ├── self.md
│ │ │ │ ├── sequential.md
│ │ │ │ └── sync_method_call.md
│ │ │ ├── actors.md
│ │ │ ├── classes/
│ │ │ │ ├── inheritance.md
│ │ │ │ ├── initialization.md
│ │ │ │ └── intro.md
│ │ │ ├── collections/
│ │ │ │ ├── dicts.md
│ │ │ │ ├── lists.md
│ │ │ │ └── sets.md
│ │ │ ├── collections.md
│ │ │ ├── compilation/
│ │ │ │ └── incremental.md
│ │ │ ├── compilation.md
│ │ │ ├── control_flow/
│ │ │ │ ├── actors.md
│ │ │ │ ├── after_sleep.md
│ │ │ │ ├── for.md
│ │ │ │ ├── if_else.md
│ │ │ │ └── while.md
│ │ │ ├── control_flow.md
│ │ │ ├── environment/
│ │ │ │ ├── interactive_stdin.md
│ │ │ │ ├── stdin.md
│ │ │ │ └── variables.md
│ │ │ ├── environment.md
│ │ │ ├── ext/
│ │ │ │ └── integrating_c_library.md
│ │ │ ├── functions/
│ │ │ │ ├── actor_methods.md
│ │ │ │ └── higher_order.md
│ │ │ ├── functions.md
│ │ │ ├── hello/
│ │ │ │ ├── args.md
│ │ │ │ ├── running_tests.md
│ │ │ │ └── shebang.md
│ │ │ ├── hello.md
│ │ │ ├── index.md
│ │ │ ├── install.md
│ │ │ ├── install_tip.md
│ │ │ ├── language/
│ │ │ │ ├── bindings_scope.md
│ │ │ │ ├── comments.md
│ │ │ │ ├── common_programming_concepts.md
│ │ │ │ ├── environment_capabilities.md
│ │ │ │ ├── errors_exceptions.md
│ │ │ │ ├── expressions_operators.md
│ │ │ │ ├── missing_values_failures.md
│ │ │ │ ├── modeling_data_interfaces.md
│ │ │ │ ├── optionals_none.md
│ │ │ │ ├── organizing_code.md
│ │ │ │ └── state_concurrency.md
│ │ │ ├── language.md
│ │ │ ├── modules.md
│ │ │ ├── naming.md
│ │ │ ├── package_management.md
│ │ │ ├── pkg/
│ │ │ │ ├── add_dependency.md
│ │ │ │ ├── fetch_dependencies.md
│ │ │ │ ├── fingerprint.md
│ │ │ │ ├── local_dependencies.md
│ │ │ │ ├── override_dependency.md
│ │ │ │ ├── package_index.md
│ │ │ │ └── remove_dependency.md
│ │ │ ├── primitives/
│ │ │ │ ├── complex.md
│ │ │ │ ├── float.md
│ │ │ │ ├── integers.md
│ │ │ │ ├── scalars.md
│ │ │ │ └── tuples.md
│ │ │ ├── primitives.md
│ │ │ ├── projects/
│ │ │ │ └── directory_structure.md
│ │ │ ├── projects.md
│ │ │ ├── protocols/
│ │ │ │ ├── dispatch.md
│ │ │ │ └── intro.md
│ │ │ ├── rts.md
│ │ │ ├── security/
│ │ │ │ ├── capabilities.md
│ │ │ │ └── intro.md
│ │ │ ├── security.md
│ │ │ ├── stdlib/
│ │ │ │ ├── builtin_protocols/
│ │ │ │ │ ├── collection.md
│ │ │ │ │ ├── general.md
│ │ │ │ │ ├── hashable.md
│ │ │ │ │ └── numeric.md
│ │ │ │ ├── builtin_protocols.md
│ │ │ │ ├── math.md
│ │ │ │ ├── re.md
│ │ │ │ └── standard_library.md
│ │ │ ├── stdlib.md
│ │ │ ├── testing/
│ │ │ │ ├── async_actor_test.md
│ │ │ │ ├── env_test.md
│ │ │ │ ├── failures_errors.md
│ │ │ │ ├── flaky.md
│ │ │ │ ├── perf_record.md
│ │ │ │ ├── performance.md
│ │ │ │ ├── snapshot.md
│ │ │ │ ├── stress.md
│ │ │ │ ├── sync_actor_test.md
│ │ │ │ └── unit_test.md
│ │ │ ├── testing.md
│ │ │ ├── types/
│ │ │ │ ├── effects.md
│ │ │ │ ├── explicit.md
│ │ │ │ ├── generics.md
│ │ │ │ ├── intro.md
│ │ │ │ ├── optionals.md
│ │ │ │ └── troubleshooting.md
│ │ │ ├── working_with_zig.md
│ │ │ └── zig_dependencies.md
│ │ ├── svgbob.css
│ │ └── theme/
│ │ ├── acton-theme.css
│ │ ├── acton-theme.js
│ │ ├── content-width.css
│ │ ├── detail-toggles.css
│ │ ├── detail-toggles.js
│ │ ├── guide-links.css
│ │ ├── guide-links.js
│ │ ├── sbscode.css
│ │ ├── sbscode_copy.js
│ │ ├── tabs.css
│ │ └── tabs.js
│ ├── dev.md
│ ├── git-develop-workflow.md
│ ├── git-feature-workflow.md
│ ├── run-example.py
│ ├── triage.md
│ ├── tutorial/
│ │ ├── README.md
│ │ ├── example-0.md
│ │ ├── example-1.md
│ │ ├── example-2.md
│ │ └── example-3.md
│ └── wrapping_c_libraries.md
├── ecolift/
│ ├── CLAUDE.md
│ ├── repos/
│ │ └── .gitignore
│ └── string_interpolation.md
├── examples/
│ ├── .acton
│ ├── StringsAndBytes.act
│ ├── abs.act
│ ├── average.act
│ ├── bsplit.act
│ ├── client.act
│ ├── count.act
│ ├── counter.act
│ ├── eq_list_dict.act
│ ├── files.act
│ ├── helloworld.act
│ ├── http_server.act
│ ├── inter.act
│ ├── print_time.act
│ ├── reprtest.act
│ ├── server.act
│ ├── sieve.act
│ ├── sumto.act
│ └── worker.act
├── homebrew/
│ └── Formula/
│ └── acton.rb
├── slides/
│ └── ActonCompiler.pptx
├── test/
│ ├── .acton
│ ├── Makefile
│ └── count.act
├── utils/
│ ├── actonmon
│ ├── changelog-find-missing-link-defs.py
│ ├── lldb/
│ │ ├── README.md
│ │ └── acton.py
│ └── update-changelog.sh
├── version.mk
└── workspace/
├── MRO.hs
├── Plan-scribble.txt
├── Plan.txt
├── Semantics.txt
├── Type-hierarchy.act
├── Type-hierarchy.txt
├── Typesystem.txt
├── anomaly_detector/
│ ├── acton_anomaly_detector2.py
│ ├── acton_anomaly_detector3.py
│ ├── acton_anomaly_detector_demo.py
│ ├── acton_anomaly_detector_demo2.py
│ └── datasets/
│ └── selected/
│ ├── level_change/
│ │ ├── ambient_temperature_system_failure.csv
│ │ ├── ec2_cpu_utilization_825cc2.csv
│ │ ├── ec2_cpu_utilization_ac20cd.csv
│ │ ├── grok_asg_anomaly.csv
│ │ ├── rds_cpu_utilization_cc0c53.csv
│ │ └── rds_cpu_utilization_e47b3b.csv
│ ├── outliers/
│ │ ├── ec2_cpu_utilization_fe7f93.csv
│ │ └── rogue_agent_key_hold.csv
│ ├── seasonal/
│ │ ├── Twitter_volume_GOOG.csv
│ │ ├── art_daily_jumpsdown.csv
│ │ ├── art_daily_jumpsup.csv
│ │ ├── art_daily_jumpsup_noised.csv
│ │ ├── art_daily_jumpsup_noised_trended.csv
│ │ ├── art_daily_jumpsup_noised_trended_det.csv
│ │ ├── art_daily_jumpsup_noised_trended_det2.csv
│ │ ├── art_daily_jumpsup_noised_trended_det2_ts.csv
│ │ ├── art_daily_nojump.csv
│ │ ├── exchange-2_cpc_results.csv
│ │ ├── exchange-2_cpm_results.csv
│ │ ├── exchange-3_cpm_results.csv
│ │ ├── nyc_taxi.csv
│ │ ├── occupancy_6005.csv
│ │ └── occupancy_t4013.csv
│ ├── trending/
│ │ └── ambient_temperature_system_failure.csv
│ └── variance_change/
│ └── exchange-3_cpm_results.csv
├── concurrent_taskpool/
│ ├── Makefile
│ ├── src/
│ │ ├── Makefile
│ │ ├── concurrent_task_pool.h
│ │ ├── concurrent_task_pool_list.c
│ │ ├── concurrent_task_pool_tree.c
│ │ └── fastrand.h
│ └── tests_and_benchmarks/
│ ├── Makefile
│ ├── benchmarking_scripts/
│ │ ├── compare_old_new
│ │ ├── compare_settings
│ │ ├── get_series
│ │ ├── get_series_avg
│ │ ├── get_series_q
│ │ ├── get_series_r
│ │ ├── get_series_r_avg
│ │ ├── rank_param_settings
│ │ ├── rank_param_settings_d_h
│ │ ├── rank_param_settings_freqs
│ │ └── rank_param_settings_freqs_d_h
│ ├── concurrent_task_pool_test_multithreaded.c
│ └── concurrent_task_pool_test_multithreaded_mixed.c
├── micke/
│ ├── Makefile
│ ├── bytesview.c
│ ├── bytesview.h
│ ├── bytesview.py
│ ├── bytesview_test.c
│ ├── flow.txt
│ └── processing.txt
├── misc-examples/
│ ├── divtest.act
│ ├── loess_smoother.act
│ ├── loess_smoother3.act
│ ├── loess_smoother4.act
│ ├── loess_smoother5.act
│ ├── numpyfns.act
│ └── timestest.act
└── upgrades/
├── upgrade_v1
├── upgrade_v1.act
├── upgrade_v2
└── upgrade_v2.act
Showing preview only (351K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (3925 symbols across 162 files)
FILE: backend/actondb.c
function error (line 79) | void error(char *msg) {
function _get_nonce (line 91) | int64_t _get_nonce(unsigned int * fastrandstate)
type membership (line 115) | typedef struct membership
type sockaddr_in (line 139) | struct sockaddr_in
function membership (line 142) | membership * get_membership(int my_id)
function free_membership (line 166) | void free_membership(membership * m)
type client_descriptor (line 195) | typedef struct client_descriptor
function client_descriptor (line 202) | client_descriptor * get_client_descriptor(struct sockaddr_in addr, int s...
function free_client_descriptor (line 211) | void free_client_descriptor(client_descriptor * cd)
function add_client_to_membership (line 216) | int add_client_to_membership(struct sockaddr_in addr, int sockfd, char *...
function client_descriptor (line 239) | client_descriptor * lookup_client_by_fd(int fd, skiplist_t * clients)
function create_state_schema (line 250) | int create_state_schema(db_t * db, unsigned int * fastrandstate)
function create_queue_schema (line 277) | int create_queue_schema(db_t * db, unsigned int * fastrandstate)
function db_schema_t (line 293) | db_schema_t * get_schema(db_t * db, WORD table_key)
function get_ack_packet (line 307) | int get_ack_packet(int status, write_query * q,
function get_gossip_ack_packet (line 325) | int get_gossip_ack_packet(int status, gossip_listen_message * q,
function handle_write_query (line 343) | int handle_write_query(write_query * wq, db_t * db, unsigned int * fastr...
function vector_clock (line 402) | vector_clock * get_empty_vc()
function vector_clock (line 407) | vector_clock * get_local_vc(int my_id)
function count_cells (line 416) | int count_cells(db_row_t* result, int * max_depth)
function cell (line 436) | cell * serialize_cells(db_row_t* result, cell * cells, int64_t table_key...
function get_read_response_packet (line 477) | int get_read_response_packet(db_row_t* result, read_query * q, db_schema...
function db_row_t (line 546) | db_row_t* handle_read_query(read_query * q, db_schema_t ** schema, db_t ...
function remote_server (line 565) | remote_server * lookup_client_by_client_socket_addr(struct sockaddr_in *...
function handle_gossip_listen_message (line 576) | int handle_gossip_listen_message(gossip_listen_message * msg, client_des...
function get_range_read_response_packet (line 590) | int get_range_read_response_packet(snode_t* start_row, snode_t* end_row,...
function handle_range_read_query (line 647) | int handle_range_read_query(range_read_query * q,
function get_queue_ack_packet (line 675) | int get_queue_ack_packet(int status, queue_query_message * q,
function get_queue_read_response_packet (line 693) | int get_queue_read_response_packet(snode_t* start_row, snode_t* end_row,...
function handle_create_queue (line 748) | int handle_create_queue(queue_query_message * q, db_t * db, unsigned int...
function handle_delete_queue (line 756) | int handle_delete_queue(queue_query_message * q, db_t * db, unsigned int...
function handle_subscribe_queue (line 764) | int handle_subscribe_queue(queue_query_message * q, int * clientfd, int6...
function handle_unsubscribe_queue (line 776) | int handle_unsubscribe_queue(queue_query_message * q, db_t * db, unsigne...
function handle_enqueue (line 787) | int handle_enqueue(queue_query_message * q, db_t * db, unsigned int * fa...
function handle_read_queue (line 826) | int handle_read_queue(queue_query_message * q,
function handle_consume_queue (line 845) | int handle_consume_queue(queue_query_message * q, db_t * db, unsigned in...
function get_txn_ack_packet (line 859) | int get_txn_ack_packet(int status, txn_message * q,
function handle_new_txn (line 878) | int handle_new_txn(txn_message * q, db_t * db, unsigned int * fastrandst...
function handle_validate_txn (line 910) | int handle_validate_txn(txn_message * q, db_t * db, unsigned int * fastr...
function handle_commit_txn (line 918) | int handle_commit_txn(txn_message * q, db_t * db, unsigned int * fastran...
function handle_abort_txn (line 934) | int handle_abort_txn(txn_message * q, db_t * db, unsigned int * fastrand...
function handle_socket_nop (line 942) | int handle_socket_nop(int * childfd, int * status)
function handle_socket_close (line 956) | int handle_socket_close(int * childfd, int * status)
function add_remote_server_to_list (line 974) | int add_remote_server_to_list(remote_server * rs, skiplist_t * peer_list...
function add_remote_server_to_membership (line 1000) | int add_remote_server_to_membership(remote_server * rs, membership * m, ...
function add_peer_to_membership (line 1017) | int add_peer_to_membership(char *hostname, unsigned short portno, struct...
function handle_client_message (line 1041) | int handle_client_message(int childfd, int msg_len, db_t * db, membershi...
function get_join_packet (line 1300) | int get_join_packet(int status, int rack_id, int dc_id, char * hostname,...
function get_agreement_propose_packet (line 1318) | int get_agreement_propose_packet(int status, membership_state * membersh...
function get_agreement_response_packet (line 1336) | int get_agreement_response_packet(int status, membership_state * members...
function get_agreement_notify_packet (line 1354) | int get_agreement_notify_packet(int status, membership_state * membershi...
function get_agreement_notify_ack_packet (line 1371) | int get_agreement_notify_ack_packet(int status, membership_agreement_msg...
function membership_state (line 1389) | membership_state * get_membership_state_from_server_list(skiplist_t * se...
function no_live_nodes (line 1414) | int no_live_nodes(skiplist_t * list)
function no_live_or_unknown_nodes (line 1429) | int no_live_or_unknown_nodes(skiplist_t * list)
function is_min_live_node (line 1444) | int is_min_live_node(int id, skiplist_t * list)
function mark_live (line 1473) | int mark_live(membership * m, int sender_id)
function mark_dead (line 1491) | int mark_dead(membership * m, int sender_id)
function send_join_message (line 1509) | int send_join_message(int rack_id, int dc_id, char * hostname, unsigned ...
function propose_local_membership (line 1539) | int propose_local_membership(membership * m, vector_clock * my_vc, membe...
function merge_membership_agreement_msg_to_list (line 1632) | int merge_membership_agreement_msg_to_list(membership_agreement_msg * ma...
function merge_membership_agreement_msg_to_client_list (line 1703) | int merge_membership_agreement_msg_to_client_list(membership_agreement_m...
function handle_agreement_propose_message (line 1783) | int handle_agreement_propose_message(membership_agreement_msg * ma, memb...
function handle_agreement_response_message (line 1815) | int handle_agreement_response_message(membership_agreement_msg * ma, mem...
function auto_update_group_queue_subscriptions (line 1885) | int auto_update_group_queue_subscriptions(membership * m, db_t * db, uns...
function install_agreed_view (line 1945) | int install_agreed_view(membership_agreement_msg * ma, membership * m, v...
function notify_new_view_to_clients (line 2045) | int notify_new_view_to_clients(membership * m, membership_agreement_msg ...
function handle_agreement_notify_message (line 2085) | int handle_agreement_notify_message(membership_agreement_msg * ma, membe...
function handle_agreement_notify_ack_message (line 2092) | int handle_agreement_notify_ack_message(membership_agreement_msg * ma, m...
function parse_gossip_message (line 2097) | int parse_gossip_message(void * rcv_buf, size_t rcv_msg_len, membership_...
function handle_join_message (line 2122) | int handle_join_message(int childfd, int msg_len, membership * m, db_t *...
function handle_server_message (line 2224) | int handle_server_message(int childfd, int msg_len, membership * m, db_t...
type argp_arguments (line 2401) | typedef struct argp_arguments
function error_t (line 2414) | error_t parse_opt (int key, char *arg, struct argp_state *state)
type timeval (line 2491) | struct timeval
type tm (line 2492) | struct tm
function main (line 2534) | int main(int argc, char **argv) {
FILE: backend/client_api.c
type dbc_stat (line 28) | struct dbc_stat
function zeroize_dbc_ops_stats (line 30) | void zeroize_dbc_ops_stats(struct dbc_ops_stat *ops_stat, const char *na...
function init_dbc_stats (line 51) | void init_dbc_stats() {
function stat_start (line 61) | void stat_start(struct dbc_ops_stat *ops_stat, struct timespec *ts_start) {
function stat_stop (line 67) | void stat_stop(struct dbc_ops_stat *ops_stat, struct timespec *ts_start,...
function queue_callback_cmp (line 101) | int queue_callback_cmp(WORD e1, WORD e2)
function queue_group_callback_cmp (line 124) | int queue_group_callback_cmp(WORD e1, WORD e2)
function remote_db_t (line 148) | remote_db_t * get_remote_db(int replication_factor, int rack_id, int dc_...
function handle_socket_close (line 201) | int handle_socket_close(int * childfd)
function install_gossiped_view (line 217) | int install_gossiped_view(membership_agreement_msg * ma, remote_db_t * d...
function comm_wake_up (line 318) | void comm_wake_up(remote_db_t *db) {
type timeval (line 326) | struct timeval
function add_server_to_membership (line 552) | int add_server_to_membership(char *hostname, int portno, int status, rem...
function rts_descriptor (line 606) | rts_descriptor * get_rts_descriptor(int rack_id, int dc_id, char *hostna...
function free_rts_descriptor (line 637) | void free_rts_descriptor(WORD rts_d)
function WORD (line 642) | WORD get_rts_key(WORD rts)
function WORD (line 647) | WORD get_rts_live_field(WORD rts)
function add_rts_to_membership (line 652) | int add_rts_to_membership(int rack_id, int dc_id, char *hostname, int lo...
function actor_descriptor (line 714) | actor_descriptor * get_actor_descriptor(long actor_id, rts_descriptor * ...
function free_actor_descriptor (line 724) | void free_actor_descriptor(actor_descriptor * a)
function skiplist_t (line 729) | skiplist_t * get_rtses_for_actor(long actor_id, remote_db_t * db)
function rts_descriptor (line 747) | rts_descriptor * get_first_rts_for_actor(long actor_id, remote_db_t * db)
function skiplist_t (line 756) | skiplist_t * get_local_actors(remote_db_t * db)
function skiplist_t (line 775) | skiplist_t * get_remote_actors(remote_db_t * db)
function is_actor_local (line 794) | int is_actor_local(long actor_id, remote_db_t * db)
function update_actor_placement (line 822) | int update_actor_placement(remote_db_t * db)
function add_actor_to_membership (line 868) | int add_actor_to_membership(long actor_id, remote_db_t * db)
function msg_callback (line 940) | msg_callback * add_msg_callback(int64_t nonce, void (*callback)(void *),...
function add_reply_to_nonce (line 962) | int add_reply_to_nonce(void * reply, short reply_type, int64_t nonce, re...
function delete_msg_callback (line 1007) | int delete_msg_callback(int64_t nonce, remote_db_t * db)
function _get_nonce (line 1031) | int64_t _get_nonce(remote_db_t * db)
function get_nonce (line 1044) | int64_t get_nonce(remote_db_t * db)
function vector_clock (line 1064) | vector_clock * get_and_increment_lc(remote_db_t * db, int node_id)
function vector_clock (line 1077) | vector_clock * get_lc(remote_db_t * db)
function update_lc_protected (line 1082) | int update_lc_protected(remote_db_t * db, vector_clock * vc_in)
function close_remote_db (line 1093) | int close_remote_db(remote_db_t * db)
function free_remote_db (line 1109) | int free_remote_db(remote_db_t * db)
function error (line 1128) | void error(char *msg) {
function send_packet (line 1132) | int send_packet(void * buf, unsigned len, int sockfd)
function send_packet_wait_reply (line 1150) | int send_packet_wait_reply(void * out_buf, unsigned out_len, int sockfd,...
function wait_on_msg_callback (line 1175) | int wait_on_msg_callback(msg_callback * mc, remote_db_t * db)
function send_packet_wait_replies_async (line 1211) | int send_packet_wait_replies_async(void * out_buf, unsigned out_len, int...
function send_packet_wait_replies_sync (line 1242) | int send_packet_wait_replies_sync(void * out_buf, unsigned out_len, int6...
function remote_insert_in_txn (line 1256) | int remote_insert_in_txn(WORD * column_values, int no_cols, int no_prima...
function remote_update_in_txn (line 1355) | int remote_update_in_txn(int * col_idxs, int no_cols, WORD * column_valu...
function remote_delete_row_in_txn (line 1361) | int remote_delete_row_in_txn(WORD * column_values, int no_primary_keys, ...
function remote_delete_cell_in_txn (line 1433) | int remote_delete_cell_in_txn(WORD * column_values, int no_primary_keys,...
function remote_delete_by_index_in_txn (line 1505) | int remote_delete_by_index_in_txn(WORD index_key, int idx_idx, WORD tabl...
function get_db_rows_forest_from_read_response (line 1514) | int get_db_rows_forest_from_read_response(range_read_response_message * ...
function db_row_t (line 1588) | db_row_t* get_db_rows_tree_from_read_response(range_read_response_messag...
function remote_search_in_txn (line 1635) | int remote_search_in_txn(WORD* primary_keys, int no_primary_keys, db_row...
function remote_search_clustering_in_txn (line 1721) | int remote_search_clustering_in_txn(WORD* primary_keys, int no_primary_k...
function remote_search_columns_in_txn (line 1807) | int remote_search_columns_in_txn(WORD* primary_keys, int no_primary_keys...
function remote_search_index_in_txn (line 1815) | int remote_search_index_in_txn(WORD index_key, int idx_idx, db_row_t** r...
function remote_range_search_in_txn (line 1822) | int remote_range_search_in_txn(WORD* start_primary_keys, WORD* end_prima...
function remote_range_search_clustering_in_txn (line 1908) | int remote_range_search_clustering_in_txn(WORD* primary_keys, int no_pri...
function remote_range_search_index_in_txn (line 1998) | int remote_range_search_index_in_txn(int idx_idx, WORD start_idx_key, WO...
function remote_read_full_table_in_txn (line 2007) | int remote_read_full_table_in_txn(snode_t** start_row, snode_t** end_row...
function remote_print_long_table (line 2099) | void remote_print_long_table(WORD table_key, remote_db_t * db)
function remote_create_queue_in_txn (line 2139) | int remote_create_queue_in_txn(WORD table_key, WORD queue_id, int * mino...
function remote_delete_queue_in_txn (line 2211) | int remote_delete_queue_in_txn(WORD table_key, WORD queue_id, int * mino...
function remote_enqueue_in_txn (line 2283) | int remote_enqueue_in_txn(WORD * column_values, int no_cols, WORD blob, ...
function remote_read_queue_in_txn (line 2356) | int remote_read_queue_in_txn(WORD consumer_id, WORD shard_id, WORD app_i...
function remote_consume_queue_in_txn (line 2462) | int remote_consume_queue_in_txn(WORD consumer_id, WORD shard_id, WORD ap...
function _remote_subscribe_queue (line 2539) | int _remote_subscribe_queue(WORD consumer_id, WORD shard_id, WORD app_id...
function _remote_unsubscribe_queue (line 2642) | int _remote_unsubscribe_queue(WORD consumer_id, WORD shard_id, WORD app_...
function remote_subscribe_queue_in_txn (line 2743) | int remote_subscribe_queue_in_txn(WORD consumer_id, WORD shard_id, WORD ...
function remote_unsubscribe_queue_in_txn (line 2751) | int remote_unsubscribe_queue_in_txn(WORD consumer_id, WORD shard_id, WOR...
function remote_subscribe_queue (line 2758) | int remote_subscribe_queue(WORD consumer_id, WORD shard_id, WORD app_id,...
function remote_unsubscribe_queue (line 2766) | int remote_unsubscribe_queue(WORD consumer_id, WORD shard_id, WORD app_i...
function remote_subscribe_group (line 2772) | int remote_subscribe_group(WORD consumer_id, WORD shard_id, WORD app_id,...
function remote_unsubscribe_group (line 2780) | int remote_unsubscribe_group(WORD consumer_id, WORD shard_id, WORD app_i...
function remote_add_queue_to_group (line 2785) | int remote_add_queue_to_group(WORD table_key, WORD queue_id, WORD group_...
function remote_remove_queue_from_group (line 2851) | int remote_remove_queue_from_group(WORD table_key, WORD queue_id, WORD g...
function queue_callback (line 2920) | queue_callback * get_queue_client_callback(WORD consumer_id, WORD shard_...
function subscribe_queue_client (line 2945) | int subscribe_queue_client(WORD consumer_id, WORD shard_id, WORD app_id,...
function unsubscribe_queue_client (line 2984) | int unsubscribe_queue_client(WORD consumer_id, WORD shard_id, WORD app_i...
function subscribe_to_group (line 3014) | int subscribe_to_group(WORD consumer_id, WORD shard_id, WORD app_id, WOR...
function unsubscribe_from_group (line 3053) | int unsubscribe_from_group(WORD consumer_id, WORD shard_id, WORD app_id,...
function uuid_t (line 3087) | uuid_t * remote_new_txn(remote_db_t * db)
function _remote_validate_txn (line 3159) | int _remote_validate_txn(uuid_t * txnid, vector_clock * version, remote_...
function remote_validate_txn (line 3226) | int remote_validate_txn(uuid_t * txnid, int * minority_status, remote_db...
function _remote_abort_txn (line 3241) | int _remote_abort_txn(uuid_t * txnid, remote_server * rs_in, remote_db_t...
function remote_abort_txn (line 3307) | int remote_abort_txn(uuid_t * txnid, remote_db_t * db)
function _remote_persist_txn (line 3312) | int _remote_persist_txn(uuid_t * txnid, vector_clock * version, remote_s...
function remote_commit_txn (line 3381) | int remote_commit_txn(uuid_t * txnid, int * minority_status, remote_db_t...
function txn_state (line 3472) | txn_state * get_client_txn_state(uuid_t txnid, remote_db_t * db)
function uuid_t (line 3485) | uuid_t * new_client_txn(remote_db_t * db, unsigned int * seedptr)
function close_client_txn (line 3509) | int close_client_txn(uuid_t txnid, remote_db_t * db)
function msg_callback (line 3533) | msg_callback * get_msg_callback(int64_t nonce, WORD client_id, void (*ca...
function add_reply_to_msg_callback (line 3559) | int add_reply_to_msg_callback(void * reply, short reply_type, msg_callba...
function free_msg_callback (line 3594) | void free_msg_callback(msg_callback * mc)
function gossip_callback_args (line 3605) | gossip_callback_args * get_gossip_callback_args(membership_state * membe...
function free_gossip_callback_args (line 3613) | void free_gossip_callback_args(gossip_callback_args * qca)
function gossip_callback (line 3618) | gossip_callback * get_gossip_callback(void (*callback)(gossip_callback_a...
function wait_on_gossip_callback (line 3629) | int wait_on_gossip_callback(gossip_callback * qc)
function free_gossip_callback (line 3651) | void free_gossip_callback(gossip_callback * qc)
function listen_to_gossip (line 3656) | int listen_to_gossip(int status, int rack_id, int dc_id, char * hostname...
FILE: backend/client_api.h
type dbc_ops_stat (line 63) | struct dbc_ops_stat {
type dbc_stat (line 118) | struct dbc_stat {
type msg_callback (line 130) | typedef struct msg_callback
type remote_db_t (line 149) | typedef struct remote_db {
type gossip_callback_args (line 187) | typedef struct gossip_callback_args
type gossip_callback (line 193) | typedef struct gossip_callback
type rts_descriptor (line 321) | typedef struct rts_descriptor
type actor_descriptor (line 348) | typedef struct actor_descriptor
FILE: backend/comm.c
function parse_message_v1 (line 27) | int parse_message_v1(void * rcv_buf, size_t rcv_msg_len, void ** out_msg...
function parse_message (line 190) | int parse_message(void * rcv_buf, size_t rcv_msg_len, void ** out_msg, s...
function read_full_packet (line 358) | int read_full_packet(int * sockfd, char * inbuf, size_t inbuf_size, int ...
function sockaddr_cmp (line 439) | int sockaddr_cmp(WORD a1, WORD a2)
function remote_server (line 475) | remote_server * get_remote_server(char *hostname, unsigned short portno,
function update_listen_socket (line 547) | int update_listen_socket(remote_server * rs, char *hostname, unsigned sh...
function connect_remote_server (line 605) | int connect_remote_server(remote_server * rs)
function free_remote_server (line 639) | void free_remote_server(remote_server * rs)
function free_remote_server_ptr (line 645) | void free_remote_server_ptr(WORD ptr)
FILE: backend/comm.h
type remote_server (line 45) | typedef struct remote_server
type sockaddr_in (line 59) | struct sockaddr_in
type sockaddr_in (line 59) | struct sockaddr_in
FILE: backend/consumer_state.h
type group_state (line 27) | typedef struct group_state group_state;
type group_queue_consumer_state (line 29) | typedef struct group_queue_consumer_state {
type consumer_state (line 39) | typedef struct consumer_state {
FILE: backend/db.c
function db_row_t (line 34) | db_row_t * create_empty_row(WORD key)
function db_row_t (line 60) | db_row_t * create_db_row_schemaless(WORD * column_values, int * primary_...
function db_row_t (line 110) | db_row_t * create_db_row_schemaless2(WORD * keys, int no_keys, WORD * co...
function db_row_t (line 151) | db_row_t * create_db_row_sf(WORD * column_values, db_schema_t * schema, ...
function free_db_cell (line 158) | void free_db_cell(db_row_t * row, db_t * db)
function free_db_row (line 187) | void free_db_row(db_row_t * row, db_schema_t * schema, db_t * db)
function db_t (line 192) | db_t * get_db()
function db_delete_db (line 214) | int db_delete_db(db_t * db)
function db_dump_db (line 223) | int db_dump_db(db_t * db)
function db_schema_t (line 231) | db_schema_t* db_create_schema(int * col_types, int no_cols, int * primar...
function free_schema (line 275) | void free_schema(db_schema_t * schema)
function db_create_table (line 291) | int db_create_table(WORD table_key, db_schema_t* schema, db_t * db, unsi...
function db_create_index (line 319) | int db_create_index(int new_index, WORD table_key, db_t * db, unsigned i...
function db_delete_table (line 326) | int db_delete_table(WORD table_key, db_t * db)
function table_insert (line 348) | int table_insert(WORD * column_values, int no_cols, int no_clustering_ke...
function table_update (line 438) | int table_update(WORD * column_values, int no_cols, int no_clustering_ke...
function db_row_t (line 496) | db_row_t* table_search(WORD* primary_keys, db_table_t * table)
function table_range_search (line 512) | int table_range_search(WORD* start_primary_keys, WORD* end_primary_keys,...
function table_verify_row_range_version (line 545) | int table_verify_row_range_version(WORD* start_primary_keys, WORD* end_p...
function table_range_search_copy (line 577) | int table_range_search_copy(WORD* start_primary_keys, WORD* end_primary_...
function db_row_t (line 587) | db_row_t* table_search_clustering(WORD* primary_keys, WORD* clustering_k...
function table_verify_cell_version (line 624) | int table_verify_cell_version(WORD* primary_keys, int no_primary_keys, W...
function table_range_search_clustering (line 648) | int table_range_search_clustering(WORD* primary_keys, WORD* start_cluste...
function print_long_db (line 691) | void print_long_db(db_t * db)
function print_long_table (line 699) | void print_long_table(db_table_t * table)
function print_long_row (line 707) | void print_long_row(db_row_t* row)
function long_row_to_string (line 717) | void long_row_to_string(db_row_t* row, char * to_string, int * len, char...
function table_verify_cell_range_version (line 779) | int table_verify_cell_range_version(WORD* primary_keys, int no_primary_k...
function WORD (line 830) | WORD* table_search_columns(WORD* primary_keys, WORD* clustering_keys, in...
function db_row_t (line 861) | db_row_t* table_search_index(WORD index_key, int idx_idx, db_table_t * t...
function table_verify_index_version (line 879) | int table_verify_index_version(WORD index_key, int idx_idx, vector_clock...
function table_range_search_index (line 893) | int table_range_search_index(int idx_idx, WORD start_idx_key, WORD end_i...
function table_verify_index_range_version (line 907) | int table_verify_index_range_version(int idx_idx, WORD start_idx_key, WO...
function table_delete_row (line 940) | int table_delete_row(WORD* primary_keys, vector_clock * version, db_tabl...
function table_delete_by_index (line 961) | int table_delete_by_index(WORD index_key, int idx_idx, db_table_t * table)
function db_insert_transactional (line 980) | int db_insert_transactional(WORD * column_values, int no_cols, int no_cl...
function db_insert (line 998) | int db_insert(WORD * column_values, int no_cols, int no_clustering_keys,...
function db_update_transactional (line 1003) | int db_update_transactional(WORD * column_values, int no_cols, int no_cl...
function db_update (line 1015) | int db_update(WORD * column_values, int no_cols, int no_clustering_keys,...
function db_row_t (line 1020) | db_row_t* db_search(WORD* primary_keys, WORD table_key, db_t * db)
function db_range_search (line 1032) | int db_range_search(WORD* start_primary_keys, WORD* end_primary_keys, sn...
function db_verify_row_range_version (line 1044) | int db_verify_row_range_version(WORD* start_primary_keys, WORD* end_prim...
function db_range_search_copy (line 1058) | int db_range_search_copy(WORD* start_primary_keys, WORD* end_primary_key...
function db_row_t (line 1070) | db_row_t* db_search_clustering(WORD* primary_keys, WORD* clustering_keys...
function db_verify_cell_version (line 1082) | int db_verify_cell_version(WORD* primary_keys, int no_primary_keys, WORD...
function db_range_search_clustering (line 1094) | int db_range_search_clustering(WORD* primary_keys, WORD* start_clusterin...
function db_verify_cell_range_version (line 1106) | int db_verify_cell_range_version(WORD* primary_keys, int no_primary_keys...
function WORD (line 1120) | WORD* db_search_columns(WORD* primary_keys, WORD* clustering_keys, int n...
function db_row_t (line 1132) | db_row_t* db_search_index(WORD index_key, int idx_idx, WORD table_key, d...
function db_verify_index_version (line 1144) | int db_verify_index_version(WORD index_key, int idx_idx, WORD table_key,...
function db_range_search_index (line 1156) | int db_range_search_index(int idx_idx, WORD start_idx_key, WORD end_idx_...
function db_verify_index_range_version (line 1168) | int db_verify_index_range_version(int idx_idx, WORD start_idx_key, WORD ...
function db_delete_row_transactional (line 1181) | int db_delete_row_transactional(WORD* primary_keys, vector_clock * versi...
function db_delete_row (line 1196) | int db_delete_row(WORD* primary_keys, WORD table_key, db_t * db, unsigne...
function db_delete_by_index (line 1201) | int db_delete_by_index(WORD index_key, int idx_idx, WORD table_key, db_t...
FILE: backend/db.h
type db_schema_t (line 82) | typedef struct db_schema {
type db_table_t (line 96) | typedef struct db_table {
type db_cell_t (line 110) | typedef struct db_cell {
type db_cell_t (line 130) | typedef db_cell_t db_row_t;
type db_t (line 132) | typedef struct db {
FILE: backend/failure_detector/cells.c
function serialize_vc (line 32) | int serialize_vc(vector_clock * vc, void ** buf, unsigned * len)
function deserialize_vc (line 46) | int deserialize_vc(void * buf, unsigned msg_len, vector_clock ** vc)
function cell_address (line 68) | cell_address * init_cell_address(int64_t table_key, int64_t * keys, int ...
function cell_address (line 78) | cell_address * init_cell_address_copy(int64_t table_key, int64_t * keys,...
function cell_address (line 90) | cell_address * init_cell_address_copy2(int64_t table_key, int64_t * prim...
function cell_address (line 109) | cell_address * init_cell_address_single_key_copy(int64_t table_key, int6...
function copy_cell_address (line 120) | int copy_cell_address(cell_address * ca, int64_t table_key, int64_t * ke...
function free_cell_address (line 130) | void free_cell_address(cell_address * ca)
function init_cell_address_msg (line 136) | void init_cell_address_msg(CellAddressMessage * msg, cell_address * ca)
function cell_address (line 145) | cell_address * init_cell_address_from_msg(CellAddressMessage * msg)
function free_cell_address_msg (line 150) | void free_cell_address_msg(CellAddressMessage * msg)
function serialize_cell_address (line 155) | int serialize_cell_address(cell_address * ca, void ** buf, unsigned * len)
function deserialize_cell_address (line 169) | int deserialize_cell_address(void * buf, unsigned msg_len, cell_address ...
function equals_cell_address (line 186) | int equals_cell_address(cell_address * ca1, cell_address * ca2)
function cell (line 221) | cell * init_cell(int64_t table_key, int64_t * keys, int no_keys, int64_t...
function copy_cell (line 236) | void copy_cell(cell * ca, int64_t table_key, int64_t * keys, int no_keys...
function cell (line 269) | cell * init_cell_copy(int64_t table_key, int64_t * keys, int no_keys, in...
function cell_address (line 276) | cell_address * get_cell_address(cell * c)
function free_cell_ptrs (line 281) | void free_cell_ptrs(cell * ca)
function free_cell (line 300) | void free_cell(cell * ca)
function init_cell_msg (line 306) | void init_cell_msg(VersionedCellMessage * msg, cell * ca, VectorClockMes...
function cell (line 344) | cell * copy_cell_from_msg(cell * c, VersionedCellMessage * msg)
function cell (line 350) | cell * init_cell_from_msg(VersionedCellMessage * msg)
function free_cell_msg (line 363) | void free_cell_msg(VersionedCellMessage * msg)
function serialize_cell (line 375) | int serialize_cell(cell * ca, void ** buf, unsigned * len)
function deserialize_cell (line 391) | int deserialize_cell(void * buf, unsigned msg_len, cell ** ca)
function equals_cell (line 408) | int equals_cell(cell * ca1, cell * ca2)
FILE: backend/failure_detector/cells.h
type cell_address (line 15) | typedef struct cell_address
type cell (line 36) | typedef struct cell
FILE: backend/failure_detector/db_messages.pb-c.c
function node_state_message__init (line 24) | void node_state_message__init
function node_state_message__get_packed_size (line 30) | size_t node_state_message__get_packed_size
function node_state_message__pack (line 36) | size_t node_state_message__pack
function node_state_message__pack_to_buffer (line 43) | size_t node_state_message__pack_to_buffer
function NodeStateMessage (line 50) | NodeStateMessage *
function node_state_message__free_unpacked (line 60) | void node_state_message__free_unpacked
function vector_clock_message__init (line 69) | void vector_clock_message__init
function vector_clock_message__get_packed_size (line 75) | size_t vector_clock_message__get_packed_size
function vector_clock_message__pack (line 81) | size_t vector_clock_message__pack
function vector_clock_message__pack_to_buffer (line 88) | size_t vector_clock_message__pack_to_buffer
function VectorClockMessage (line 95) | VectorClockMessage *
function vector_clock_message__free_unpacked (line 105) | void vector_clock_message__free_unpacked
function gossip_message__init (line 114) | void gossip_message__init
function gossip_message__get_packed_size (line 120) | size_t gossip_message__get_packed_size
function gossip_message__pack (line 126) | size_t gossip_message__pack
function gossip_message__pack_to_buffer (line 133) | size_t gossip_message__pack_to_buffer
function GossipMessage (line 140) | GossipMessage *
function gossip_message__free_unpacked (line 150) | void gossip_message__free_unpacked
function gossip_listen_message__init (line 159) | void gossip_listen_message__init
function gossip_listen_message__get_packed_size (line 165) | size_t gossip_listen_message__get_packed_size
function gossip_listen_message__pack (line 171) | size_t gossip_listen_message__pack
function gossip_listen_message__pack_to_buffer (line 178) | size_t gossip_listen_message__pack_to_buffer
function GossipListenMessage (line 185) | GossipListenMessage *
function gossip_listen_message__free_unpacked (line 195) | void gossip_listen_message__free_unpacked
function membership_view_message__init (line 204) | void membership_view_message__init
function membership_view_message__get_packed_size (line 210) | size_t membership_view_message__get_packed_size
function membership_view_message__pack (line 216) | size_t membership_view_message__pack
function membership_view_message__pack_to_buffer (line 223) | size_t membership_view_message__pack_to_buffer
function MembershipViewMessage (line 230) | MembershipViewMessage *
function membership_view_message__free_unpacked (line 240) | void membership_view_message__free_unpacked
function membership_agreement_message__init (line 249) | void membership_agreement_message__init
function membership_agreement_message__get_packed_size (line 255) | size_t membership_agreement_message__get_packed_size
function membership_agreement_message__pack (line 261) | size_t membership_agreement_message__pack
function membership_agreement_message__pack_to_buffer (line 268) | size_t membership_agreement_message__pack_to_buffer
function MembershipAgreementMessage (line 275) | MembershipAgreementMessage *
function membership_agreement_message__free_unpacked (line 285) | void membership_agreement_message__free_unpacked
function cell_address_message__init (line 294) | void cell_address_message__init
function cell_address_message__get_packed_size (line 300) | size_t cell_address_message__get_packed_size
function cell_address_message__pack (line 306) | size_t cell_address_message__pack
function cell_address_message__pack_to_buffer (line 313) | size_t cell_address_message__pack_to_buffer
function CellAddressMessage (line 320) | CellAddressMessage *
function cell_address_message__free_unpacked (line 330) | void cell_address_message__free_unpacked
function cell_message__init (line 339) | void cell_message__init
function cell_message__get_packed_size (line 345) | size_t cell_message__get_packed_size
function cell_message__pack (line 351) | size_t cell_message__pack
function cell_message__pack_to_buffer (line 358) | size_t cell_message__pack_to_buffer
function CellMessage (line 365) | CellMessage *
function cell_message__free_unpacked (line 375) | void cell_message__free_unpacked
function versioned_cell_message__init (line 384) | void versioned_cell_message__init
function versioned_cell_message__get_packed_size (line 390) | size_t versioned_cell_message__get_packed_size
function versioned_cell_message__pack (line 396) | size_t versioned_cell_message__pack
function versioned_cell_message__pack_to_buffer (line 403) | size_t versioned_cell_message__pack_to_buffer
function VersionedCellMessage (line 410) | VersionedCellMessage *
function versioned_cell_message__free_unpacked (line 420) | void versioned_cell_message__free_unpacked
function server_message__init (line 429) | void server_message__init
function server_message__get_packed_size (line 435) | size_t server_message__get_packed_size
function server_message__pack (line 441) | size_t server_message__pack
function server_message__pack_to_buffer (line 448) | size_t server_message__pack_to_buffer
function ServerMessage (line 455) | ServerMessage *
function server_message__free_unpacked (line 465) | void server_message__free_unpacked
function client_message__init (line 474) | void client_message__init
function client_message__get_packed_size (line 480) | size_t client_message__get_packed_size
function client_message__pack (line 486) | size_t client_message__pack
function client_message__pack_to_buffer (line 493) | size_t client_message__pack_to_buffer
function ClientMessage (line 500) | ClientMessage *
function client_message__free_unpacked (line 510) | void client_message__free_unpacked
function write_query_message__init (line 519) | void write_query_message__init
function write_query_message__get_packed_size (line 525) | size_t write_query_message__get_packed_size
function write_query_message__pack (line 531) | size_t write_query_message__pack
function write_query_message__pack_to_buffer (line 538) | size_t write_query_message__pack_to_buffer
function WriteQueryMessage (line 545) | WriteQueryMessage *
function write_query_message__free_unpacked (line 555) | void write_query_message__free_unpacked
function read_query_message__init (line 564) | void read_query_message__init
function read_query_message__get_packed_size (line 570) | size_t read_query_message__get_packed_size
function read_query_message__pack (line 576) | size_t read_query_message__pack
function read_query_message__pack_to_buffer (line 583) | size_t read_query_message__pack_to_buffer
function ReadQueryMessage (line 590) | ReadQueryMessage *
function read_query_message__free_unpacked (line 600) | void read_query_message__free_unpacked
function ack_message__init (line 609) | void ack_message__init
function ack_message__get_packed_size (line 615) | size_t ack_message__get_packed_size
function ack_message__pack (line 621) | size_t ack_message__pack
function ack_message__pack_to_buffer (line 628) | size_t ack_message__pack_to_buffer
function AckMessage (line 635) | AckMessage *
function ack_message__free_unpacked (line 645) | void ack_message__free_unpacked
function range_read_query_message__init (line 654) | void range_read_query_message__init
function range_read_query_message__get_packed_size (line 660) | size_t range_read_query_message__get_packed_size
function range_read_query_message__pack (line 666) | size_t range_read_query_message__pack
function range_read_query_message__pack_to_buffer (line 673) | size_t range_read_query_message__pack_to_buffer
function RangeReadQueryMessage (line 680) | RangeReadQueryMessage *
function range_read_query_message__free_unpacked (line 690) | void range_read_query_message__free_unpacked
function range_read_response_message__init (line 699) | void range_read_response_message__init
function range_read_response_message__get_packed_size (line 705) | size_t range_read_response_message__get_packed_size
function range_read_response_message__pack (line 711) | size_t range_read_response_message__pack
function range_read_response_message__pack_to_buffer (line 718) | size_t range_read_response_message__pack_to_buffer
function RangeReadResponseMessage (line 725) | RangeReadResponseMessage *
function range_read_response_message__free_unpacked (line 735) | void range_read_response_message__free_unpacked
function txn_message__init (line 744) | void txn_message__init
function txn_message__get_packed_size (line 750) | size_t txn_message__get_packed_size
function txn_message__pack (line 756) | size_t txn_message__pack
function txn_message__pack_to_buffer (line 763) | size_t txn_message__pack_to_buffer
function TxnMessage (line 770) | TxnMessage *
function txn_message__free_unpacked (line 780) | void txn_message__free_unpacked
function queue_query_message__init (line 789) | void queue_query_message__init
function queue_query_message__get_packed_size (line 795) | size_t queue_query_message__get_packed_size
function queue_query_message__pack (line 801) | size_t queue_query_message__pack
function queue_query_message__pack_to_buffer (line 808) | size_t queue_query_message__pack_to_buffer
function QueueQueryMessage (line 815) | QueueQueryMessage *
function queue_query_message__free_unpacked (line 825) | void queue_query_message__free_unpacked
function consumer_id__init (line 834) | void consumer_id__init
function consumer_id__get_packed_size (line 840) | size_t consumer_id__get_packed_size
function consumer_id__pack (line 846) | size_t consumer_id__pack
function consumer_id__pack_to_buffer (line 853) | size_t consumer_id__pack_to_buffer
function ConsumerID (line 860) | ConsumerID *
function consumer_id__free_unpacked (line 870) | void consumer_id__free_unpacked
function create_queue_message__init (line 879) | void create_queue_message__init
function create_queue_message__get_packed_size (line 885) | size_t create_queue_message__get_packed_size
function create_queue_message__pack (line 891) | size_t create_queue_message__pack
function create_queue_message__pack_to_buffer (line 898) | size_t create_queue_message__pack_to_buffer
function CreateQueueMessage (line 905) | CreateQueueMessage *
function create_queue_message__free_unpacked (line 915) | void create_queue_message__free_unpacked
function delete_queue_message__init (line 924) | void delete_queue_message__init
function delete_queue_message__get_packed_size (line 930) | size_t delete_queue_message__get_packed_size
function delete_queue_message__pack (line 936) | size_t delete_queue_message__pack
function delete_queue_message__pack_to_buffer (line 943) | size_t delete_queue_message__pack_to_buffer
function DeleteQueueMessage (line 950) | DeleteQueueMessage *
function delete_queue_message__free_unpacked (line 960) | void delete_queue_message__free_unpacked
function subscribe_queue_message__init (line 969) | void subscribe_queue_message__init
function subscribe_queue_message__get_packed_size (line 975) | size_t subscribe_queue_message__get_packed_size
function subscribe_queue_message__pack (line 981) | size_t subscribe_queue_message__pack
function subscribe_queue_message__pack_to_buffer (line 988) | size_t subscribe_queue_message__pack_to_buffer
function SubscribeQueueMessage (line 995) | SubscribeQueueMessage *
function subscribe_queue_message__free_unpacked (line 1005) | void subscribe_queue_message__free_unpacked
function unsubscribe_queue_message__init (line 1014) | void unsubscribe_queue_message__init
function unsubscribe_queue_message__get_packed_size (line 1020) | size_t unsubscribe_queue_message__get_packed_size
function unsubscribe_queue_message__pack (line 1026) | size_t unsubscribe_queue_message__pack
function unsubscribe_queue_message__pack_to_buffer (line 1033) | size_t unsubscribe_queue_message__pack_to_buffer
function UnsubscribeQueueMessage (line 1040) | UnsubscribeQueueMessage *
function unsubscribe_queue_message__free_unpacked (line 1050) | void unsubscribe_queue_message__free_unpacked
function enqueue_message__init (line 1059) | void enqueue_message__init
function enqueue_message__get_packed_size (line 1065) | size_t enqueue_message__get_packed_size
function enqueue_message__pack (line 1071) | size_t enqueue_message__pack
function enqueue_message__pack_to_buffer (line 1078) | size_t enqueue_message__pack_to_buffer
function EnqueueMessage (line 1085) | EnqueueMessage *
function enqueue_message__free_unpacked (line 1095) | void enqueue_message__free_unpacked
function enqueue_response_message__init (line 1104) | void enqueue_response_message__init
function enqueue_response_message__get_packed_size (line 1110) | size_t enqueue_response_message__get_packed_size
function enqueue_response_message__pack (line 1116) | size_t enqueue_response_message__pack
function enqueue_response_message__pack_to_buffer (line 1123) | size_t enqueue_response_message__pack_to_buffer
function EnqueueResponseMessage (line 1130) | EnqueueResponseMessage *
function enqueue_response_message__free_unpacked (line 1140) | void enqueue_response_message__free_unpacked
function read_queue_message__init (line 1149) | void read_queue_message__init
function read_queue_message__get_packed_size (line 1155) | size_t read_queue_message__get_packed_size
function read_queue_message__pack (line 1161) | size_t read_queue_message__pack
function read_queue_message__pack_to_buffer (line 1168) | size_t read_queue_message__pack_to_buffer
function ReadQueueMessage (line 1175) | ReadQueueMessage *
function read_queue_message__free_unpacked (line 1185) | void read_queue_message__free_unpacked
function read_queue_response_message__init (line 1194) | void read_queue_response_message__init
function read_queue_response_message__get_packed_size (line 1200) | size_t read_queue_response_message__get_packed_size
function read_queue_response_message__pack (line 1206) | size_t read_queue_response_message__pack
function read_queue_response_message__pack_to_buffer (line 1213) | size_t read_queue_response_message__pack_to_buffer
function ReadQueueResponseMessage (line 1220) | ReadQueueResponseMessage *
function read_queue_response_message__free_unpacked (line 1230) | void read_queue_response_message__free_unpacked
function consume_queue_message__init (line 1239) | void consume_queue_message__init
function consume_queue_message__get_packed_size (line 1245) | size_t consume_queue_message__get_packed_size
function consume_queue_message__pack (line 1251) | size_t consume_queue_message__pack
function consume_queue_message__pack_to_buffer (line 1258) | size_t consume_queue_message__pack_to_buffer
function ConsumeQueueMessage (line 1265) | ConsumeQueueMessage *
function consume_queue_message__free_unpacked (line 1275) | void consume_queue_message__free_unpacked
function consume_queue_response_message__init (line 1284) | void consume_queue_response_message__init
function consume_queue_response_message__get_packed_size (line 1290) | size_t consume_queue_response_message__get_packed_size
function consume_queue_response_message__pack (line 1296) | size_t consume_queue_response_message__pack
function consume_queue_response_message__pack_to_buffer (line 1303) | size_t consume_queue_response_message__pack_to_buffer
function ConsumeQueueResponseMessage (line 1310) | ConsumeQueueResponseMessage *
function consume_queue_response_message__free_unpacked (line 1320) | void consume_queue_response_message__free_unpacked
FILE: backend/failure_detector/db_messages.pb-c.h
type NodeStateMessage (line 32) | typedef struct NodeStateMessage NodeStateMessage;
type VectorClockMessage (line 33) | typedef struct VectorClockMessage VectorClockMessage;
type GossipMessage (line 34) | typedef struct GossipMessage GossipMessage;
type GossipListenMessage (line 35) | typedef struct GossipListenMessage GossipListenMessage;
type MembershipViewMessage (line 36) | typedef struct MembershipViewMessage MembershipViewMessage;
type MembershipAgreementMessage (line 37) | typedef struct MembershipAgreementMessage MembershipAgreementMessage;
type CellAddressMessage (line 38) | typedef struct CellAddressMessage CellAddressMessage;
type CellMessage (line 39) | typedef struct CellMessage CellMessage;
type VersionedCellMessage (line 40) | typedef struct VersionedCellMessage VersionedCellMessage;
type ServerMessage (line 41) | typedef struct ServerMessage ServerMessage;
type ClientMessage (line 42) | typedef struct ClientMessage ClientMessage;
type WriteQueryMessage (line 43) | typedef struct WriteQueryMessage WriteQueryMessage;
type ReadQueryMessage (line 44) | typedef struct ReadQueryMessage ReadQueryMessage;
type AckMessage (line 45) | typedef struct AckMessage AckMessage;
type RangeReadQueryMessage (line 46) | typedef struct RangeReadQueryMessage RangeReadQueryMessage;
type RangeReadResponseMessage (line 47) | typedef struct RangeReadResponseMessage RangeReadResponseMessage;
type TxnMessage (line 48) | typedef struct TxnMessage TxnMessage;
type QueueQueryMessage (line 49) | typedef struct QueueQueryMessage QueueQueryMessage;
type ConsumerID (line 50) | typedef struct ConsumerID ConsumerID;
type CreateQueueMessage (line 51) | typedef struct CreateQueueMessage CreateQueueMessage;
type DeleteQueueMessage (line 52) | typedef struct DeleteQueueMessage DeleteQueueMessage;
type SubscribeQueueMessage (line 53) | typedef struct SubscribeQueueMessage SubscribeQueueMessage;
type UnsubscribeQueueMessage (line 54) | typedef struct UnsubscribeQueueMessage UnsubscribeQueueMessage;
type EnqueueMessage (line 55) | typedef struct EnqueueMessage EnqueueMessage;
type EnqueueResponseMessage (line 56) | typedef struct EnqueueResponseMessage EnqueueResponseMessage;
type ReadQueueMessage (line 57) | typedef struct ReadQueueMessage ReadQueueMessage;
type ReadQueueResponseMessage (line 58) | typedef struct ReadQueueResponseMessage ReadQueueResponseMessage;
type ConsumeQueueMessage (line 59) | typedef struct ConsumeQueueMessage ConsumeQueueMessage;
type ConsumeQueueResponseMessage (line 60) | typedef struct ConsumeQueueResponseMessage ConsumeQueueResponseMessage;
type NodeStateMessage (line 68) | struct NodeStateMessage
type VectorClockMessage (line 86) | struct VectorClockMessage
type GossipMessage (line 99) | struct GossipMessage
type GossipListenMessage (line 110) | struct GossipListenMessage
type MembershipViewMessage (line 121) | struct MembershipViewMessage
type MembershipAgreementMessage (line 135) | struct MembershipAgreementMessage
type CellAddressMessage (line 155) | struct CellAddressMessage
type CellMessage (line 167) | struct CellMessage
type VersionedCellMessage (line 181) | struct VersionedCellMessage
type ServerMessage (line 200) | struct ServerMessage
type ClientMessage (line 220) | struct ClientMessage
type WriteQueryMessage (line 239) | struct WriteQueryMessage
type ReadQueryMessage (line 259) | struct ReadQueryMessage
type AckMessage (line 272) | struct AckMessage
type RangeReadQueryMessage (line 289) | struct RangeReadQueryMessage
type RangeReadResponseMessage (line 303) | struct RangeReadResponseMessage
type TxnMessage (line 317) | struct TxnMessage
type QueueQueryMessage (line 342) | struct QueueQueryMessage
type ConsumerID (line 367) | struct ConsumerID
type CreateQueueMessage (line 379) | struct CreateQueueMessage
type DeleteQueueMessage (line 391) | struct DeleteQueueMessage
type SubscribeQueueMessage (line 403) | struct SubscribeQueueMessage
type UnsubscribeQueueMessage (line 416) | struct UnsubscribeQueueMessage
type EnqueueMessage (line 429) | struct EnqueueMessage
type EnqueueResponseMessage (line 445) | struct EnqueueResponseMessage
type ReadQueueMessage (line 458) | struct ReadQueueMessage
type ReadQueueResponseMessage (line 472) | struct ReadQueueResponseMessage
type ConsumeQueueMessage (line 486) | struct ConsumeQueueMessage
type ConsumeQueueResponseMessage (line 500) | struct ConsumeQueueResponseMessage
FILE: backend/failure_detector/db_messages_test.c
function write_msg_to_file (line 33) | int write_msg_to_file (unsigned char *buff, unsigned len, FILE * fp)
function read_msg_from_file (line 42) | int read_msg_from_file (unsigned max_length, unsigned char *buff, FILE *...
function write_read_from_file (line 60) | void write_read_from_file(void * buf_w, unsigned len_w, unsigned char *b...
function main (line 84) | int main (int argc, const char * argv[])
FILE: backend/failure_detector/db_queries.c
function write_query (line 36) | write_query * init_write_query(cell * cell, int msg_type, uuid_t * txnid...
function write_query (line 46) | write_query * init_write_query_copy(cell * cell, int msg_type, uuid_t * ...
function write_query (line 64) | write_query * build_insert_in_txn(WORD * column_values, int no_cols, int...
function write_query (line 72) | write_query * build_delete_row_in_txn(WORD* primary_keys, int no_primary...
function write_query (line 78) | write_query * build_delete_cell_in_txn(WORD* keys, int no_primary_keys, ...
function write_query (line 84) | write_query * build_delete_by_index_in_txn(WORD index_key, int idx_idx, ...
function write_query (line 90) | write_query * build_update_in_txn(int * col_idxs, int no_cols, WORD * co...
function free_write_query (line 96) | void free_write_query(write_query * ca)
function init_write_query_msg (line 102) | void init_write_query_msg(WriteQueryMessage * msg, write_query * ca, Ver...
function write_query (line 120) | write_query * init_write_query_from_msg(WriteQueryMessage * msg)
function free_write_query_msg (line 127) | void free_write_query_msg(WriteQueryMessage * msg)
function serialize_write_query (line 135) | int serialize_write_query(write_query * ca, void ** buf, unsigned * len,...
function deserialize_write_query (line 211) | int deserialize_write_query(void * buf, unsigned msg_len, write_query **...
function equals_write_query (line 253) | int equals_write_query(write_query * ca1, write_query * ca2)
function read_query (line 267) | read_query * init_read_query(cell_address * cell_address, uuid_t * txnid...
function read_query (line 276) | read_query * init_read_query_copy(cell_address * cell_address, uuid_t * ...
function read_query (line 293) | read_query * build_search_in_txn(WORD* primary_keys, int no_primary_keys...
function read_query (line 300) | read_query * build_search_clustering_in_txn(WORD* primary_keys, int no_p...
function read_query (line 307) | read_query * build_search_columns_in_txn(WORD* primary_keys, int no_prim...
function read_query (line 313) | read_query * build_search_index_in_txn(WORD index_key, int idx_idx, WORD...
function free_read_query (line 320) | void free_read_query(read_query * ca)
function init_read_query_msg (line 326) | void init_read_query_msg(ReadQueryMessage * msg, read_query * ca, CellAd...
function read_query (line 343) | read_query * init_read_query_from_msg(ReadQueryMessage * msg)
function free_read_query_msg (line 350) | void free_read_query_msg(ReadQueryMessage * msg)
function serialize_read_query (line 357) | int serialize_read_query(read_query * ca, void ** buf, unsigned * len, v...
function deserialize_read_query (line 398) | int deserialize_read_query(void * buf, unsigned msg_len, read_query ** ca)
function equals_read_query (line 437) | int equals_read_query(read_query * ca1, read_query * ca2)
function range_read_query (line 450) | range_read_query * build_range_search_in_txn(WORD* start_primary_keys, W...
function range_read_query (line 458) | range_read_query * build_range_search_clustering_in_txn(WORD* primary_ke...
function range_read_query (line 466) | range_read_query * build_range_search_index_in_txn(int idx_idx, WORD sta...
function range_read_query (line 472) | range_read_query * build_wildcard_range_search_in_txn(WORD table_key, uu...
function range_read_query (line 483) | range_read_query * init_range_read_query(cell_address * start_cell_addre...
function free_range_read_query (line 493) | void free_range_read_query(range_read_query * ca)
function range_read_query (line 500) | range_read_query * init_range_read_query_copy(cell_address * start_cell_...
function init_range_read_query_msg (line 518) | void init_range_read_query_msg(RangeReadQueryMessage * msg, range_read_q...
function range_read_query (line 536) | range_read_query * init_range_read_query_from_msg(RangeReadQueryMessage ...
function free_range_read_query_msg (line 544) | void free_range_read_query_msg(RangeReadQueryMessage * msg)
function serialize_range_read_query (line 552) | int serialize_range_read_query(range_read_query * ca, void ** buf, unsig...
function deserialize_range_read_query (line 595) | int deserialize_range_read_query(void * buf, unsigned msg_len, range_rea...
function equals_range_read_query (line 639) | int equals_range_read_query(range_read_query * ca1, range_read_query * ca2)
function ack_message (line 655) | ack_message * init_ack_message(cell_address * cell_address, int status, ...
function ack_message (line 665) | ack_message * init_ack_message_copy(cell_address * cell_address, int sta...
function free_ack_message (line 683) | void free_ack_message(ack_message * ca)
function init_ack_message_msg (line 690) | void init_ack_message_msg(AckMessage * msg, ack_message * ca, CellAddres...
function ack_message (line 708) | ack_message * init_ack_message_from_msg(AckMessage * msg)
function free_ack_message_msg (line 715) | void free_ack_message_msg(AckMessage * msg)
function serialize_ack_message (line 723) | int serialize_ack_message(ack_message * ca, void ** buf, unsigned * len,...
function deserialize_ack_message (line 764) | int deserialize_ack_message(void * buf, unsigned msg_len, ack_message **...
function equals_ack_message (line 810) | int equals_ack_message(ack_message * ca1, ack_message * ca2)
function range_read_response_message (line 824) | range_read_response_message * init_range_read_response_message(cell * ce...
function range_read_response_message (line 834) | range_read_response_message * init_range_read_response_message_copy(cell...
function init_range_read_response_message_msg (line 856) | void init_range_read_response_message_msg(RangeReadResponseMessage * msg...
function range_read_response_message (line 887) | range_read_response_message * init_range_read_response_message_from_msg(...
function free_range_read_response_message_msg (line 897) | void free_range_read_response_message_msg(RangeReadResponseMessage * msg)
function free_range_read_response_message (line 909) | void free_range_read_response_message(range_read_response_message * ca)
function serialize_range_read_response_message (line 920) | int serialize_range_read_response_message(range_read_response_message * ...
function deserialize_range_read_response_message (line 958) | int deserialize_range_read_response_message(void * buf, unsigned msg_len...
function equals_range_read_response_message (line 1012) | int equals_range_read_response_message(range_read_response_message * ca1...
function queue_query_message (line 1030) | queue_query_message * init_query_message_basic(cell_address * cell_addre...
function queue_query_message (line 1055) | queue_query_message * build_enqueue_in_txn(WORD * column_values, int no_...
function queue_query_message (line 1063) | queue_query_message * build_read_queue_in_txn(WORD consumer_id, WORD sha...
function queue_query_message (line 1071) | queue_query_message * build_consume_queue_in_txn(WORD consumer_id, WORD ...
function queue_query_message (line 1078) | queue_query_message * build_create_queue_in_txn(WORD table_key, WORD que...
function queue_query_message (line 1084) | queue_query_message * build_delete_queue_in_txn(WORD table_key, WORD que...
function queue_query_message (line 1090) | queue_query_message * build_subscribe_queue_in_txn(WORD consumer_id, WOR...
function queue_query_message (line 1096) | queue_query_message * build_unsubscribe_queue_in_txn(WORD consumer_id, W...
function queue_query_message (line 1102) | queue_query_message * build_subscribe_group_in_txn(WORD consumer_id, WOR...
function queue_query_message (line 1108) | queue_query_message * build_unsubscribe_group_in_txn(WORD consumer_id, W...
function queue_query_message (line 1114) | queue_query_message * build_add_queue_to_group_in_txn(WORD table_key, WO...
function queue_query_message (line 1120) | queue_query_message * build_remove_queue_from_group_in_txn(WORD table_ke...
function queue_query_message (line 1127) | queue_query_message * init_create_queue_message(cell_address * cell_addr...
function queue_query_message (line 1134) | queue_query_message * init_delete_queue_message(cell_address * cell_addr...
function queue_query_message (line 1141) | queue_query_message * init_subscribe_queue_message(cell_address * cell_a...
function queue_query_message (line 1152) | queue_query_message * init_unsubscribe_queue_message(cell_address * cell...
function queue_query_message (line 1163) | queue_query_message * init_add_queue_to_group_message(cell_address * cel...
function queue_query_message (line 1171) | queue_query_message * init_remove_queue_from_group_message(cell_address ...
function queue_query_message (line 1179) | queue_query_message * init_enqueue_message(cell_address * cell_address, ...
function queue_query_message (line 1188) | queue_query_message * init_read_queue_message(cell_address * cell_addres...
function queue_query_message (line 1200) | queue_query_message * init_consume_queue_message(cell_address * cell_add...
function queue_query_message (line 1212) | queue_query_message * init_read_queue_response(cell_address * cell_addre...
function queue_query_message (line 1228) | queue_query_message * init_queue_notification(cell_address * cell_addres...
function free_queue_message (line 1244) | void free_queue_message(queue_query_message * ca)
function init_queue_message_msg (line 1255) | void init_queue_message_msg(QueueQueryMessage * msg, queue_query_message...
function queue_query_message (line 1301) | queue_query_message * init_queue_message_from_msg(QueueQueryMessage * msg)
function free_queue_message_msg (line 1375) | void free_queue_message_msg(QueueQueryMessage * msg)
function serialize_queue_message (line 1388) | int serialize_queue_message(queue_query_message * ca, void ** buf, unsig...
function deserialize_queue_message (line 1463) | int deserialize_queue_message(void * buf, unsigned msg_len, queue_query_...
function equals_queue_message (line 1577) | int equals_queue_message(queue_query_message * ca1, queue_query_message ...
function txn_message (line 1592) | txn_message * build_new_txn(uuid_t * txnid, int64_t nonce)
function txn_message (line 1602) | txn_message * build_validate_txn(uuid_t * txnid, vector_clock * version,...
function txn_message (line 1614) | txn_message * build_commit_txn(uuid_t * txnid, vector_clock * version, i...
function txn_message (line 1626) | txn_message * build_abort_txn(uuid_t * txnid, int64_t nonce)
function txn_message (line 1636) | txn_message * init_txn_message(int type,
function txn_message (line 1659) | txn_message * init_txn_message_copy(int type,
function free_txn_message (line 1705) | void free_txn_message(txn_message * ca)
function init_txn_message_msg (line 1729) | void init_txn_message_msg(TxnMessage * msg, txn_message * ca, VectorCloc...
function txn_message (line 1819) | txn_message * init_txn_message_from_msg(TxnMessage * msg)
function free_txn_message_msg (line 1845) | void free_txn_message_msg(TxnMessage * msg)
function serialize_txn_message (line 1867) | int serialize_txn_message(txn_message * ca, void ** buf, unsigned * len,...
function deserialize_txn_message (line 1940) | int deserialize_txn_message(void * buf, unsigned msg_len, txn_message **...
function equals_txn_message (line 2025) | int equals_txn_message(txn_message * ca1, txn_message * ca2)
function gossip_listen_message (line 2060) | gossip_listen_message * build_gossip_listen_msg(node_description * nd, i...
function free_gossip_listen_msg (line 2068) | void free_gossip_listen_msg(gossip_listen_message * gs)
function free_gossip_listen_message_msg (line 2074) | void free_gossip_listen_message_msg(GossipListenMessage * msg)
function serialize_gossip_listen_msg (line 2078) | int serialize_gossip_listen_msg(gossip_listen_message * gs, void ** buf,...
function deserialize_gossip_listen_msg (line 2110) | int deserialize_gossip_listen_msg(void * buf, unsigned msg_len, gossip_l...
function equals_gossip_listen_msg (line 2126) | int equals_gossip_listen_msg(gossip_listen_message * gs1, gossip_listen_...
function free_server_msg (line 2142) | void free_server_msg(ServerMessage * sm)
function deserialize_server_message (line 2192) | int deserialize_server_message(void * buf, unsigned msg_len, void ** des...
function free_client_msg (line 2260) | void free_client_msg(ClientMessage * cm)
function deserialize_client_message (line 2304) | int deserialize_client_message(void * buf, unsigned msg_len, void ** des...
FILE: backend/failure_detector/db_queries.h
type write_query (line 56) | typedef struct write_query
type write_query (line 64) | typedef write_query read_response_message;
type read_query (line 80) | typedef struct read_query
type ack_message (line 101) | typedef struct ack_message
type range_read_query (line 117) | typedef struct range_read_query
type range_read_response_message (line 139) | typedef struct range_read_response_message
type queue_query_message (line 155) | typedef struct queue_query_message
type txn_message (line 214) | typedef struct txn_message
type gossip_listen_message (line 253) | typedef struct gossip_listen_message
FILE: backend/failure_detector/fd.c
function init_ns_msg_from_description (line 35) | void init_ns_msg_from_description(NodeStateMessage * ns_msg, node_descri...
function copy_node_description (line 50) | int copy_node_description(node_description * nd, int status, int node_id...
function node_description (line 81) | node_description * init_node_description(int status, int node_id, int ra...
function free_node_description (line 90) | void free_node_description(node_description * nd)
function equals_node_description (line 97) | int equals_node_description(node_description * nd1, node_description * nd2)
function gossip_state (line 111) | gossip_state * init_gossip_state(int status, int node_id, int rack_id, i...
function free_gossip_state (line 121) | void free_gossip_state(gossip_state * gs)
function free_gossip_msg (line 127) | void free_gossip_msg(GossipMessage * msg)
function init_ns_msg (line 132) | void init_ns_msg(NodeStateMessage * ns_msg, gossip_state * gs)
function serialize_gs (line 137) | int serialize_gs(gossip_state * gs, void ** buf, unsigned * len)
function deserialize_gs (line 159) | int deserialize_gs(void * buf, unsigned msg_len, gossip_state ** gs)
function equals_gs (line 176) | int equals_gs(gossip_state * gs1, gossip_state * gs2)
function membership_state (line 196) | membership_state * init_membership_state(int no_nodes, node_description ...
function membership_state (line 207) | membership_state * clone_membership(membership_state * m)
function free_membership_state (line 225) | void free_membership_state(membership_state * ms, int do_free_vc)
function free_membership_msg (line 234) | void free_membership_msg(MembershipViewMessage * msg)
function init_membership_msg (line 249) | void init_membership_msg(MembershipViewMessage * msg, membership_state *...
function serialize_membership_state (line 277) | int serialize_membership_state(membership_state * m, void ** buf, unsign...
function membership_state (line 295) | membership_state * init_membership_from_msg(MembershipViewMessage * msg)
function deserialize_membership_state (line 316) | int deserialize_membership_state(void * buf, unsigned msg_len, membershi...
function equals_membership_state (line 331) | int equals_membership_state(membership_state * gs1, membership_state * gs2)
function membership_agreement_msg (line 381) | membership_agreement_msg * init_membership_agreement_msg(int msg_type, i...
function membership_agreement_msg (line 392) | membership_agreement_msg * get_membership_propose_msg(int ack_status, me...
function membership_agreement_msg (line 397) | membership_agreement_msg * get_membership_response_msg(int ack_status, m...
function membership_agreement_msg (line 402) | membership_agreement_msg * get_membership_notify_msg(int ack_status, mem...
function membership_agreement_msg (line 407) | membership_agreement_msg * get_membership_notify_ack_msg(int ack_status,...
function membership_agreement_msg (line 412) | membership_agreement_msg * get_membership_join_msg(int status, int rack_...
function free_membership_agreement (line 423) | void free_membership_agreement(membership_agreement_msg * ma)
function free_membership_agreement_msg (line 432) | void free_membership_agreement_msg(MembershipAgreementMessage * msg)
function serialize_membership_agreement_msg (line 441) | int serialize_membership_agreement_msg(membership_agreement_msg * ma, vo...
function deserialize_membership_agreement_msg (line 477) | int deserialize_membership_agreement_msg(void * buf, unsigned msg_len, m...
function equals_membership_agreement_msg (line 495) | int equals_membership_agreement_msg(membership_agreement_msg * ma1, memb...
FILE: backend/failure_detector/fd.h
type node_description (line 18) | typedef struct node_description
type gossip_state (line 39) | typedef struct gossip_state
type membership_state (line 54) | typedef struct membership_state
type membership_agreement_msg (line 83) | typedef struct membership_agreement_msg
FILE: backend/failure_detector/txns.h
type txn_message (line 9) | typedef struct txn_message
FILE: backend/failure_detector/vector_clock.c
function increment_vc (line 29) | int increment_vc(vector_clock * vc, int node_id)
function compare_vc (line 49) | int compare_vc(vector_clock * vc1, vector_clock * vc2)
function update_vc (line 83) | int update_vc(vector_clock * vc_dest, vector_clock * vc_src)
function update_or_replace_vc (line 110) | int update_or_replace_vc(vector_clock ** vc_dest, vector_clock * vc_src)
function add_component_vc (line 140) | int add_component_vc(vector_clock * vc, int node_id, int initial_counter)
function get_component_vc (line 166) | int64_t get_component_vc(vector_clock * vc, int node_id)
function remove_component_vc (line 180) | int remove_component_vc(vector_clock * vc, int node_id)
function cmpfunc (line 199) | int cmpfunc (const void * a, const void * b) {
function vector_clock (line 203) | vector_clock * init_vc(int init_no_nodes, int * node_ids, int64_t * coun...
function get_node_id (line 231) | int get_node_id(struct sockaddr * x)
function vector_clock (line 255) | vector_clock * init_empty_vc()
function vector_clock (line 260) | vector_clock * init_local_vc_id(int local_id)
function vector_clock (line 267) | vector_clock * init_local_vc(struct sockaddr * x)
function vector_clock (line 274) | vector_clock * copy_vc(vector_clock * vc1)
function vector_clock (line 293) | vector_clock * init_vc_from_msg(VectorClockMessage * msg)
function grow_vc (line 306) | int grow_vc(vector_clock * vc)
function free_vc (line 321) | void free_vc(vector_clock * vc)
function init_vc_msg (line 331) | void init_vc_msg(VectorClockMessage * msg_ptr, vector_clock * vc)
function free_vc_msg (line 344) | void free_vc_msg(VectorClockMessage * msg)
FILE: backend/failure_detector/vector_clock.h
type versioned_id (line 45) | typedef struct versioned_id
type vector_clock (line 51) | typedef struct vector_clock
type sockaddr (line 78) | struct sockaddr
type sockaddr (line 98) | struct sockaddr
FILE: backend/fastrand.h
function fast_srand (line 30) | inline static void fast_srand(int seed)
function fastrand (line 35) | inline static int fastrand()
FILE: backend/hash_ring.c
function hash_ring (line 24) | hash_ring * get_hash_ring()
function free_hash_ring (line 35) | void free_hash_ring(hash_ring * ring, void (*free_val)(WORD))
function add_bucket (line 48) | int add_bucket(hash_ring * ring, WORD bucket, void* (*get_key)(void *), ...
function snode_t (line 70) | snode_t * lookup_bucket(hash_ring * ring, WORD bucket_id)
function get_bucket_status (line 76) | int get_bucket_status(hash_ring * ring, WORD bucket, void* (*get_key)(vo...
function set_bucket_status (line 98) | int set_bucket_status(hash_ring * ring, WORD bucket, int status, void* (...
function mark_bucket_dead (line 128) | int mark_bucket_dead(hash_ring * ring, WORD bucket, void* (*get_key)(voi...
function mark_bucket_live (line 133) | int mark_bucket_live(hash_ring * ring, WORD bucket, void* (*get_key)(voi...
function WORD (line 138) | WORD get_buckets_for_object(hash_ring * ring, int object_id, int replica...
FILE: backend/hash_ring.h
type hash_ring (line 30) | typedef struct hash_ring
FILE: backend/hashes.h
function hash32 (line 18) | uint32_t hash32(uint32_t x)
FILE: backend/log.c
type Callback (line 27) | typedef struct {
function stdout_callback (line 53) | static void stdout_callback(log_Event *ev) {
function file_callback (line 72) | static void file_callback(log_Event *ev) {
function lock (line 84) | static void lock(void) {
function unlock (line 89) | static void unlock(void) {
function log_set_lock (line 99) | void log_set_lock(log_LockFn fn, void *udata) {
function log_set_level (line 105) | void log_set_level(int level) {
function log_set_quiet (line 110) | void log_set_quiet(bool enable) {
function log_add_callback (line 115) | int log_add_callback(log_LogFn fn, void *udata, int level) {
function log_add_fp (line 126) | int log_add_fp(FILE *fp, int level) {
function init_event (line 131) | static void init_event(log_Event *ev, void *udata) {
function log_log (line 140) | void log_log(int level, const char *file, int line, const char *fmt, ...) {
FILE: backend/log.h
type log_Event (line 18) | typedef struct {
FILE: backend/queue.c
function db_table_t (line 37) | db_table_t * get_table_by_key(WORD table_key, db_t * db)
function create_queue_table (line 46) | int create_queue_table(WORD table_id, int no_cols, int * col_types, db_t...
function get_queue_notification_packet (line 76) | int get_queue_notification_packet(WORD table_key, WORD queue_id, WORD ap...
function notify_remote_queue_subscribers (line 101) | int notify_remote_queue_subscribers(WORD table_key, WORD queue_id, db_t ...
function notify_subscriber (line 164) | void notify_subscriber(consumer_state * cs, WORD table_key, WORD queue_i...
function notify_subscribers (line 245) | void notify_subscribers(skiplist_t * subscriber_list, WORD table_key, WO...
function enqueue (line 258) | int enqueue(WORD * column_values, int no_cols, size_t last_blob_size, WO...
function lookup_consumer_state_in_group (line 331) | int lookup_consumer_state_in_group(WORD queue_id, WORD consumer_id, db_r...
function lookup_consumer_state_in_row_or_group (line 382) | int lookup_consumer_state_in_row_or_group(WORD queue_id, WORD consumer_i...
function sanity_check_consumer_read_heads (line 399) | void sanity_check_consumer_read_heads(int64_t old_read_head, int64_t old...
function sanity_check_consumer_consume_heads (line 406) | void sanity_check_consumer_consume_heads(int64_t old_read_head, int64_t ...
function is_consumer_notified (line 414) | int is_consumer_notified(consumer_state * cs, consumer_state * gqcs)
function set_consumer_notified (line 419) | void set_consumer_notified(consumer_state * cs, consumer_state * gqcs, i...
function set_private_read_head (line 427) | int set_private_read_head(WORD consumer_id, WORD shard_id, WORD app_id, ...
function set_private_consume_head (line 475) | int set_private_consume_head(WORD consumer_id, WORD shard_id, WORD app_i...
function read_queue (line 515) | int read_queue(WORD consumer_id, WORD shard_id, WORD app_id, WORD table_...
function peek_queue (line 606) | int peek_queue(WORD consumer_id, WORD shard_id, WORD app_id, WORD table_...
function replay_queue (line 669) | int replay_queue(WORD consumer_id, WORD shard_id, WORD app_id, WORD tabl...
function consume_queue (line 735) | int consume_queue(WORD consumer_id, WORD shard_id, WORD app_id, WORD tab...
function __subscribe_queue (line 785) | int __subscribe_queue(WORD consumer_id, WORD shard_id, WORD app_id, db_r...
function _subscribe_queue (line 828) | int _subscribe_queue(WORD consumer_id, WORD shard_id, WORD app_id, WORD ...
function _subscribe_group (line 850) | int _subscribe_group(WORD consumer_id, WORD shard_id, WORD app_id, WORD ...
function _unsubscribe_group (line 891) | int _unsubscribe_group(WORD consumer_id, WORD group_id, db_t * db)
function subscribe_queue (line 914) | int subscribe_queue(WORD consumer_id, WORD shard_id, WORD app_id, WORD t...
function register_remote_subscribe_queue (line 925) | int register_remote_subscribe_queue(WORD consumer_id, WORD shard_id, WOR...
function _unsubscribe_queue (line 951) | int _unsubscribe_queue(WORD consumer_id, WORD shard_id, WORD app_id, WOR...
function unsubscribe_queue (line 985) | int unsubscribe_queue(WORD consumer_id, WORD shard_id, WORD app_id, WORD...
function register_remote_unsubscribe_queue (line 991) | int register_remote_unsubscribe_queue(WORD consumer_id, WORD shard_id, W...
function _create_headers_for_group_subscribers (line 1004) | void _create_headers_for_group_subscribers(group_state * gs, db_row_t * ...
function create_headers_for_group_subscribers (line 1021) | void create_headers_for_group_subscribers(db_row_t * db_row, db_t * db, ...
function create_queue (line 1057) | int create_queue(WORD table_key, WORD queue_id, vector_clock * version, ...
function delete_queue (line 1147) | int delete_queue(WORD table_key, WORD queue_id, vector_clock * version, ...
function consumer_state (line 1222) | consumer_state * get_consumer_state(WORD consumer_id, WORD shard_id, WOR...
function free_consumer_state (line 1241) | void free_consumer_state(consumer_state * cs)
function free_consumer_state_sl (line 1255) | void free_consumer_state_sl(void * cs)
function add_consumer_state_to_group (line 1260) | int add_consumer_state_to_group(WORD queue_id, consumer_state * cs, grou...
function get_consumer_state_from_group (line 1271) | int get_consumer_state_from_group(WORD queue_id, group_state * gs, consu...
function pop_consumer_state_from_group (line 1282) | int pop_consumer_state_from_group(WORD queue_id, group_state * gs, consu...
function free_queue_table_state (line 1293) | void free_queue_table_state(WORD queue_table_state)
FILE: backend/queue_callback.c
function queue_callback_args (line 22) | queue_callback_args * get_queue_callback_args(WORD table_key, WORD queue...
function free_queue_callback_args (line 39) | void free_queue_callback_args(queue_callback_args * qca)
function queue_callback (line 44) | queue_callback * get_queue_callback(void (*callback)(queue_callback_args...
function wait_on_queue_callback (line 55) | int wait_on_queue_callback(queue_callback * qc)
function free_queue_callback (line 77) | void free_queue_callback(queue_callback * qc)
FILE: backend/queue_callback.h
type queue_callback_args (line 25) | typedef struct queue_callback_args
type queue_callback (line 39) | typedef struct queue_callback
FILE: backend/queue_groups.c
function group_state (line 24) | group_state * get_group(WORD group_id)
function free_group_state (line 36) | void free_group_state(WORD gs)
function WORD (line 41) | WORD get_group_state_key(WORD rs)
function WORD (line 45) | WORD get_group_state_live_field(WORD rs)
function clear_group (line 50) | int clear_group(group_state * group)
function delete_group (line 61) | int delete_group(group_state * group)
function activate_group (line 69) | void activate_group(group_state * group)
function deactivate_group (line 74) | void deactivate_group(group_state * group)
function add_queue_to_group (line 79) | int add_queue_to_group(group_state * group, WORD table_key, WORD queue_i...
function remove_queue_from_group (line 98) | int remove_queue_from_group(group_state * group, WORD table_key, WORD qu...
function is_queue_in_group (line 123) | int is_queue_in_group(group_state * group, WORD table_key, WORD queue_id)
function add_listener_to_group (line 147) | int add_listener_to_group(group_state * group,
function remove_listener_from_group (line 172) | int remove_listener_from_group(group_state * group, WORD consumer_id)
function lookup_listener_in_group (line 185) | int lookup_listener_in_group(group_state * group, WORD consumer_id, WORD...
FILE: backend/queue_groups.h
type group_state (line 31) | typedef struct group_state {
type consumer_state (line 39) | typedef struct consumer_state consumer_state;
FILE: backend/skiplist.c
function long_cmp (line 31) | int long_cmp(WORD e1, WORD e2) {
function uuid_cmp (line 35) | int uuid_cmp(WORD e1, WORD e2)
function skiplist_t (line 40) | skiplist_t *create_skiplist_long() {
function skiplist_t (line 44) | skiplist_t *create_skiplist_uuid() {
function skiplist_t (line 48) | skiplist_t *create_skiplist(int (*cmp)(WORD, WORD)) {
function skiplist_t (line 54) | skiplist_t *skiplist_init(skiplist_t *list, int (*cmp)(WORD, WORD)) {
function rand_level (line 72) | static int rand_level(unsigned int * seedptr) {
function skiplist_insert (line 80) | int skiplist_insert(skiplist_t *list, WORD key, WORD value, unsigned int...
function skiplist_t (line 119) | skiplist_t * skiplist_clone(skiplist_t * list, unsigned int * seedptr)
function snode_t (line 131) | snode_t *skiplist_search(skiplist_t *list, WORD key) {
function snode_t (line 147) | snode_t *skiplist_search_higher(skiplist_t *list, WORD key) {
function skiplist_get_range (line 162) | int skiplist_get_range(skiplist_t *list, WORD start_key, WORD end_key, W...
function snode_t (line 190) | snode_t *skiplist_search_lower(skiplist_t *list, WORD key) {
function skiplist_node_free (line 201) | static void skiplist_node_free(snode_t *x) {
function WORD (line 208) | WORD skiplist_delete(skiplist_t *list, WORD key) {
function skiplist_free (line 241) | void skiplist_free(skiplist_t *list)
function skiplist_free_val (line 257) | void skiplist_free_val(skiplist_t *list, void (*free_val)(WORD))
function skiplist_dump (line 274) | void skiplist_dump(skiplist_t *list) {
FILE: backend/skiplist.h
type snode_t (line 16) | typedef struct snode {
type skiplist_t (line 22) | typedef struct skiplist {
FILE: backend/test/actor_ring_tests_local.c
type actor_collection_item_t (line 50) | typedef struct actor_collection_item {
type actor_queue_item_t (line 57) | typedef struct actor_queue_item {
type actor_args (line 62) | typedef struct actor_args
function create_state_schema (line 96) | int create_state_schema(db_t * db, unsigned int * fastrandstate)
function create_queue_schema (line 128) | int create_queue_schema(db_t * db, unsigned int * fastrandstate)
function consumer_callback (line 154) | void consumer_callback(queue_callback_args * qca)
function read_queue_while_not_empty (line 162) | int read_queue_while_not_empty(actor_args * ca, int * entries_read, snod...
function checkpoint_local_state (line 203) | int checkpoint_local_state(actor_args * ca, uuid_t * txnid, unsigned int...
function send_seed_msgs (line 265) | int send_seed_msgs(actor_args * ca, int * msgs_sent, unsigned int * fast...
function send_outgoing_msgs (line 302) | int send_outgoing_msgs(actor_args * ca, int outgoing_counters[], int no_...
function process_messages (line 337) | int process_messages(snode_t * start_row, snode_t * end_row, int entries...
function produce_effects (line 389) | int produce_effects(uuid_t * txnid, actor_args * ca,
function main (line 590) | int main(int argc, char **argv) {
FILE: backend/test/actor_ring_tests_remote.c
type actor_collection_item_t (line 59) | typedef struct actor_collection_item {
type actor_queue_item_t (line 66) | typedef struct actor_queue_item {
type actor_args (line 71) | typedef struct actor_args
function db_schema_t (line 105) | db_schema_t* create_state_schema()
function create_queue_schema (line 132) | int create_queue_schema(remote_db_t * db, unsigned int * fastrandstate)
function consumer_callback (line 151) | void consumer_callback(queue_callback_args * qca)
function read_queue_while_not_empty (line 159) | int read_queue_while_not_empty(actor_args * ca, int * entries_read, snod...
function checkpoint_local_state (line 197) | int checkpoint_local_state(actor_args * ca, uuid_t * txnid, unsigned int...
function send_seed_msgs (line 258) | int send_seed_msgs(actor_args * ca, int * msgs_sent, unsigned int * fast...
function send_outgoing_msgs (line 295) | int send_outgoing_msgs(actor_args * ca, int outgoing_counters[], int no_...
function process_messages (line 330) | int process_messages(snode_t * start_row, snode_t * end_row, int entries...
function produce_effects (line 382) | int produce_effects(uuid_t * txnid, actor_args * ca,
function main (line 583) | int main(int argc, char **argv) {
FILE: backend/test/db_unit_tests.c
type actor_collection_item_t (line 22) | typedef struct actor_collection_item {
function create_schema (line 40) | int create_schema(db_t * db, unsigned int * fastrandstate) {
function populate_db (line 63) | int populate_db(db_t * db, unsigned int * fastrandstate) {
function test_search_column (line 88) | int test_search_column(db_t * db) {
function test_search_pk (line 129) | int test_search_pk(db_t * db)
function test_search_pk_ck1 (line 147) | int test_search_pk_ck1(db_t * db)
function test_search_pk_ck1_ck2 (line 168) | int test_search_pk_ck1_ck2(db_t * db)
function test_search_index (line 196) | int test_search_index(db_t * db)
function test_update (line 216) | int test_update(db_t * db)
function test_delete_pk (line 260) | int test_delete_pk(db_t * db, unsigned int * fastrandstate)
function test_delete_pk_ck1 (line 284) | int test_delete_pk_ck1(db_t * db)
function test_delete_pk_ck1_ck2 (line 293) | int test_delete_pk_ck1_ck2(db_t * db)
function test_delete_col (line 302) | int test_delete_col(db_t * db)
function test_delete_index (line 310) | int test_delete_index(db_t * db)
function test_range_search_pk (line 334) | int test_range_search_pk(db_t * db)
function test_range_search_pk_copy (line 345) | int test_range_search_pk_copy(db_t * db)
function test_range_search_pk_ck1 (line 358) | int test_range_search_pk_ck1(db_t * db)
function test_range_search_pk_ck1_ck2 (line 382) | int test_range_search_pk_ck1_ck2(db_t * db)
function test_range_search_index (line 412) | int test_range_search_index(db_t * db)
function main (line 424) | int main(int argc, char **argv) {
FILE: backend/test/queue_unit_tests.c
type actor_collection_item_t (line 31) | typedef struct actor_collection_item {
type producer_args (line 36) | typedef struct producer_args
type consumer_args (line 47) | typedef struct consumer_args
function do_enqueues (line 71) | int do_enqueues(db_t * db, WORD table_id, WORD queue_id, int no_enqueues...
function consumer_callback (line 113) | void consumer_callback(queue_callback_args * qca)
function read_queue_while_not_empty (line 121) | int read_queue_while_not_empty(consumer_args * ca, int * entries_read)
type timespec (line 209) | struct timespec
type timespec (line 277) | struct timespec
function main (line 308) | int main(int argc, char **argv) {
FILE: backend/test/skiplist_test.c
function main (line 23) | int main() {
FILE: backend/test/test_client.c
type actor_collection_item_t (line 36) | typedef struct actor_collection_item {
function db_schema_t (line 58) | db_schema_t * create_schema() {
function populate_db (line 79) | int populate_db(db_schema_t * schema, remote_db_t * db, uuid_t * txnid, ...
function delete_test (line 105) | int delete_test(db_schema_t * schema, remote_db_t * db, uuid_t * txnid, ...
function delete_all (line 114) | int delete_all(db_schema_t * schema, remote_db_t * db, uuid_t * txnid, u...
function test_search_pk (line 126) | int test_search_pk(db_schema_t * schema, remote_db_t * db, uuid_t * txni...
function test_search_pk_ck1 (line 158) | int test_search_pk_ck1(db_schema_t * schema, remote_db_t * db, uuid_t * ...
function test_search_pk_ck1_ck2 (line 194) | int test_search_pk_ck1_ck2(db_schema_t * schema, remote_db_t * db, uuid_...
function consumer_callback (line 233) | void consumer_callback(queue_callback_args * qca)
function test_create_queue (line 242) | int test_create_queue(remote_db_t * db, uuid_t * txnid)
function test_delete_queue (line 253) | int test_delete_queue(remote_db_t * db, uuid_t * txnid)
function test_subscribe_queue (line 263) | int test_subscribe_queue(remote_db_t * db, WORD consumer_id, WORD queue_id)
function test_unsubscribe_queue (line 272) | int test_unsubscribe_queue(remote_db_t * db, WORD consumer_id, WORD queu...
function test_enqueue (line 278) | int test_enqueue(remote_db_t * db, WORD queue_id, uuid_t * txnid)
function test_read_queue (line 296) | int test_read_queue(remote_db_t * db, WORD consumer_id, WORD queue_id, u...
function test_consume_queue (line 315) | int test_consume_queue(remote_db_t * db, WORD consumer_id, WORD queue_id...
function test_txn (line 321) | int test_txn(remote_db_t * db, db_schema_t * schema, unsigned * fastrand...
function main (line 372) | int main(int argc, char **argv) {
FILE: backend/txn_state.c
function txn_write_cmp (line 26) | int txn_write_cmp(WORD e1, WORD e2)
function txn_read_cmp (line 80) | int txn_read_cmp(WORD e1, WORD e2)
function txn_state (line 150) | txn_state * init_txn_state()
function set_version (line 162) | void set_version(txn_state * ts, vector_clock * vc)
function free_txn_state (line 170) | void free_txn_state(txn_state * ts)
function txn_write (line 177) | txn_write * get_txn_write(short query_type, WORD * column_values, int no...
function txn_write (line 197) | txn_write * get_dummy_txn_write(short query_type, WORD * primary_keys, i...
function txn_write (line 221) | txn_write * get_txn_queue_op(short query_type, WORD * column_values, int...
function free_txn_write (line 265) | void free_txn_write(txn_write * tw)
function txn_read (line 270) | txn_read * get_txn_read(short query_type,
function free_txn_read (line 346) | void free_txn_read(txn_read * tr)
function add_write_to_txn (line 362) | int add_write_to_txn(short query_type, WORD * column_values, int no_cols...
function add_row_read_to_txn (line 380) | int add_row_read_to_txn(WORD* primary_keys, int no_primary_keys,
function add_row_range_read_to_txn (line 399) | int add_row_range_read_to_txn(WORD* start_primary_keys, WORD* end_primar...
function add_cell_read_to_txn (line 425) | int add_cell_read_to_txn(WORD* primary_keys, int no_primary_keys, WORD* ...
function add_cell_range_read_to_txn (line 440) | int add_cell_range_read_to_txn(WORD* primary_keys, int no_primary_keys, ...
function add_col_read_to_txn (line 473) | int add_col_read_to_txn(WORD* primary_keys, int no_primary_keys, WORD* c...
function add_index_read_to_txn (line 489) | int add_index_read_to_txn(WORD* index_key, int idx_idx, WORD table_key, ...
function add_index_range_read_to_txn (line 502) | int add_index_range_read_to_txn(int idx_idx, WORD* start_idx_key, WORD* ...
function add_enqueue_to_txn (line 528) | int add_enqueue_to_txn(WORD * column_values, int no_cols, size_t blob_si...
function add_read_queue_to_txn (line 537) | int add_read_queue_to_txn(WORD consumer_id, WORD shard_id, WORD app_id, ...
function add_consume_queue_to_txn (line 556) | int add_consume_queue_to_txn(WORD consumer_id, WORD shard_id, WORD app_i...
function add_create_queue_to_txn (line 573) | int add_create_queue_to_txn(WORD table_key, WORD queue_id, txn_state * t...
function add_delete_queue_to_txn (line 582) | int add_delete_queue_to_txn(WORD table_key, WORD queue_id, txn_state * t...
function add_subscribe_queue_to_txn (line 591) | int add_subscribe_queue_to_txn(WORD consumer_id, WORD shard_id, WORD app...
function add_unsubscribe_queue_to_txn (line 599) | int add_unsubscribe_queue_to_txn(WORD consumer_id, WORD shard_id, WORD a...
FILE: backend/txn_state.h
type txn_write (line 18) | typedef struct txn_write
type txn_read (line 45) | typedef struct txn_read
type txn_state (line 82) | typedef struct txn_state
FILE: backend/txns.c
function txn_state (line 31) | txn_state * get_txn_state(uuid_t * txnid, db_t * db)
function uuid_t (line 38) | uuid_t * new_txn(db_t * db, unsigned int * seedptr)
function close_txn_state (line 66) | int close_txn_state(txn_state * ts, db_t * db)
function close_txn (line 82) | int close_txn(uuid_t * txnid, db_t * db)
function key_path_overlaps (line 91) | int key_path_overlaps(txn_read * tr, txn_write * tw)
function rw_conflict (line 135) | int rw_conflict(txn_read * tr, txn_write * tw, int check_exact_match)
function queue_op_conflict (line 165) | int queue_op_conflict(txn_write * tw1, txn_write * tw2)
function ww_conflict (line 202) | int ww_conflict(txn_write * tw1, txn_write * tw2)
function is_read_invalidated (line 216) | int is_read_invalidated(txn_read * tr, txn_state * rts, db_t * db)
function is_write_invalidated (line 324) | int is_write_invalidated(txn_write * tw, txn_state * rts, int * schema_s...
function validate_txn (line 450) | int validate_txn(uuid_t * txnid, vector_clock * version, db_t * db)
function persist_write (line 494) | int persist_write(txn_write * tw, vector_clock * version, db_t * db, uns...
function persist_txn (line 543) | int persist_txn(txn_state * ts, db_t * db, unsigned int * fastrandstate)
function abort_txn (line 582) | int abort_txn(uuid_t * txnid, db_t * db)
function commit_txn (line 587) | int commit_txn(uuid_t * txnid, vector_clock * version, db_t * db, unsign...
function db_insert_in_txn (line 632) | int db_insert_in_txn(WORD * column_values, int no_cols, int no_primary_k...
function db_row_t (line 641) | db_row_t* db_search_in_txn(WORD* primary_keys, int no_primary_keys, WORD...
function db_range_search_in_txn (line 658) | int db_range_search_in_txn(WORD* start_primary_keys, WORD* end_primary_k...
function db_row_t (line 674) | db_row_t* db_search_clustering_in_txn(WORD* primary_keys, int no_primary...
function db_range_search_clustering_in_txn (line 691) | int db_range_search_clustering_in_txn(WORD* primary_keys, int no_primary...
function db_row_t (line 707) | db_row_t* db_search_columns_in_txn(WORD* primary_keys, int no_primary_ke...
function db_row_t (line 726) | db_row_t* db_search_index_in_txn(WORD index_key, int idx_idx, WORD table...
function db_range_search_index_in_txn (line 741) | int db_range_search_index_in_txn(int idx_idx, WORD start_idx_key, WORD e...
function db_delete_row_in_txn (line 752) | int db_delete_row_in_txn(WORD* primary_keys, int no_primary_keys, WORD t...
function db_delete_cell_in_txn (line 761) | int db_delete_cell_in_txn(WORD* keys, int no_primary_keys, int no_cluste...
function db_delete_by_index_in_txn (line 770) | int db_delete_by_index_in_txn(WORD index_key, int idx_idx, WORD table_ke...
function db_update_in_txn (line 776) | int db_update_in_txn(int * col_idxs, int no_cols, size_t blob_size, WORD...
function enqueue_in_txn (line 784) | int enqueue_in_txn(WORD * column_values, int no_cols, size_t blob_size, ...
function read_queue_in_txn (line 793) | int read_queue_in_txn(WORD consumer_id, WORD shard_id, WORD app_id, WORD...
function consume_queue_in_txn (line 834) | int consume_queue_in_txn(WORD consumer_id, WORD shard_id, WORD app_id, W...
function subscribe_queue_in_txn (line 845) | int subscribe_queue_in_txn(WORD consumer_id, WORD shard_id, WORD app_id,...
function unsubscribe_queue_in_txn (line 853) | int unsubscribe_queue_in_txn(WORD consumer_id, WORD shard_id, WORD app_i...
function create_queue_in_txn (line 860) | int create_queue_in_txn(WORD table_key, WORD queue_id, uuid_t * txnid, d...
function delete_queue_in_txn (line 869) | int delete_queue_in_txn(WORD table_key, WORD queue_id, uuid_t * txnid, d...
FILE: base/builtin/Iterator.c
function B_Iterator (line 15) | B_Iterator B_IterableD_IteratorD___iter__(B_IterableD_Iterator wit, B_It...
function $WORD (line 19) | $WORD $next(B_Iterator it) {
FILE: base/builtin/atom.c
type B_atomG_class (line 15) | struct B_atomG_class
FILE: base/builtin/atom.h
type B_atomG_class (line 1) | struct B_atomG_class
FILE: base/builtin/bigint.c
function B_bigint (line 22) | B_bigint malloc_bigint() {
function zz_malloc_fit (line 31) | void zz_malloc_fit(zz_ptr res, len_t m) {
function B_bigint (line 39) | B_bigint B_bigintG_new(B_atom a, B_int base) {
function B_NoneType (line 145) | B_NoneType B_bigintD___init__(B_bigint self, B_atom a, B_int base){
function B_bigintD___serialize__ (line 150) | void B_bigintD___serialize__(B_bigint self,$Serial$state state) {
function B_bigint (line 164) | B_bigint B_bigintD___deserialize__(B_bigint res,$Serial$state state) {
function B_bool (line 183) | B_bool B_bigintD___bool__(B_bigint n) {
function B_str (line 187) | B_str B_bigintD___str__(B_bigint n) {
function B_str (line 191) | B_str B_bigintD___repr__(B_bigint n) {
function B_bigint (line 209) | B_bigint B_IntegralD_bigintD___add__(B_IntegralD_bigint wit, B_bigint a...
function B_bigint (line 215) | B_bigint B_IntegralD_bigintD___zero__(B_IntegralD_bigint wit) {
function B_complex (line 219) | B_complex B_IntegralD_bigintD___complex__(B_IntegralD_bigint wit, B_bigi...
function B_bigint (line 224) | B_bigint B_IntegralD_bigintD___fromatom__(B_IntegralD_bigint wit, B_atom...
function B_bigint (line 228) | B_bigint B_IntegralD_bigintD___mul__(B_IntegralD_bigint wit, B_bigint a...
function B_bigint (line 234) | B_bigint B_IntegralD_bigintD___pow__(B_IntegralD_bigint wit, B_bigint a,...
function B_bigint (line 254) | B_bigint B_IntegralD_bigintD___neg__(B_IntegralD_bigint wit, B_bigint a) {
function B_bigint (line 260) | B_bigint B_IntegralD_bigintD___pos__(B_IntegralD_bigint wit, B_bigint a) {
function $WORD (line 264) | $WORD B_IntegralD_bigintD_real(B_IntegralD_bigint wit, B_bigint a, B_Rea...
function $WORD (line 269) | $WORD B_IntegralD_bigintD_imag(B_IntegralD_bigint wit, B_bigint a, B_Rea...
function $WORD (line 274) | $WORD B_IntegralD_bigintD___abs__(B_IntegralD_bigint wit, B_bigint a, B_...
function B_bigint (line 281) | B_bigint B_IntegralD_bigintD_conjugate(B_IntegralD_bigint wit, B_bigint...
function B_float (line 285) | B_float B_IntegralD_bigintD___float__ (B_IntegralD_bigint wit, B_bigint ...
function $WORD (line 289) | $WORD B_IntegralD_bigintD___trunc__ (B_IntegralD_bigint wit, B_bigint n,...
function $WORD (line 293) | $WORD B_IntegralD_bigintD___floor__ (B_IntegralD_bigint wit, B_bigint n,...
function $WORD (line 297) | $WORD B_IntegralD_bigintD___ceil__ (B_IntegralD_bigint wit, B_bigint n, ...
function B_bigint (line 303) | B_bigint B_IntegralD_bigintD___round__ (B_IntegralD_bigint wit, B_bigint...
function $WORD (line 321) | $WORD B_IntegralD_bigintD_numerator (B_IntegralD_bigint wit, B_bigint n,...
function $WORD (line 325) | $WORD B_IntegralD_bigintD_denominator (B_IntegralD_bigint wit, B_bigint ...
function B_int (line 330) | B_int B_IntegralD_bigintD___int__ (B_IntegralD_bigint wit, B_bigint n) {
function B_int (line 341) | B_int B_IntegralD_bigintD___index__ (B_IntegralD_bigint wit, B_bigint n) {
function B_tuple (line 352) | B_tuple B_IntegralD_bigintD___divmod__(B_IntegralD_bigint wit, B_bigint ...
function B_bigint (line 364) | B_bigint B_IntegralD_bigintD___floordiv__(B_IntegralD_bigint wit, B_bigi...
function B_bigint (line 375) | B_bigint B_IntegralD_bigintD___mod__(B_IntegralD_bigint wit, B_bigint a,...
function B_bigint (line 380) | B_bigint B_IntegralD_bigintD___lshift__(B_IntegralD_bigint wit, B_bigin...
function B_bigint (line 411) | B_bigint B_IntegralD_bigintD___rshift__(B_IntegralD_bigint wit, B_bigin...
function B_bigint (line 438) | B_bigint B_IntegralD_bigintD___invert__(B_IntegralD_bigint wit, B_bigin...
function twocompl (line 452) | void twocompl(unsigned long *dst, unsigned long *src, long len) {
function B_bigint (line 465) | B_bigint B_LogicalD_IntegralD_bigintD___and__(B_LogicalD_IntegralD_bigin...
function B_bigint (line 515) | B_bigint B_LogicalD_IntegralD_bigintD___or__(B_LogicalD_IntegralD_bigint...
function B_bigint (line 562) | B_bigint B_LogicalD_IntegralD_bigintD___xor__(B_LogicalD_IntegralD_bigin...
function B_bigint (line 608) | B_bigint B_MinusD_IntegralD_bigintD___sub__(B_MinusD_IntegralD_bigint wi...
function B_float (line 617) | B_float B_DivD_bigintD___truediv__ (B_DivD_bigint wit, B_bigint a, B_big...
function B_bool (line 636) | B_bool B_OrdD_bigintD___eq__ (B_OrdD_bigint wit, B_bigint a, B_bigint b) {
function B_bool (line 640) | B_bool B_OrdD_bigintD___ne__ (B_OrdD_bigint wit, B_bigint a, B_bigint b) {
function B_bool (line 644) | B_bool B_OrdD_bigintD___lt__ (B_OrdD_bigint wit, B_bigint a, B_bigint b) {
function B_bool (line 648) | B_bool B_OrdD_bigintD___le__ (B_OrdD_bigint wit, B_bigint a, B_bigint b) {
function B_bool (line 652) | B_bool B_OrdD_bigintD___gt__ (B_OrdD_bigint wit, B_bigint a, B_bigint b) {
function B_bool (line 656) | B_bool B_OrdD_bigintD___ge__ (B_OrdD_bigint wit, B_bigint a, B_bigint b) {
function B_bool (line 662) | B_bool B_HashableD_bigintD___eq__(B_HashableD_bigint wit, B_bigint a, B_...
function B_bool (line 666) | B_bool B_HashableD_bigintD___ne__(B_HashableD_bigint wit, B_bigint a, B_...
function B_NoneType (line 670) | B_NoneType B_HashableD_bigintD_hash(B_HashableD_bigint wit, B_bigint a, ...
function fromB_bigint (line 681) | long fromB_bigint(B_bigint n) {
function B_bigint (line 692) | B_bigint toB_bigint(long n) {
function B_bigint (line 703) | B_bigint toB_bigint2(char *str) {
function get_str0 (line 741) | int get_str0(bool ishead, zz_ptr n, zz_ptr dens[], int d, unsigned char ...
function set_str0 (line 812) | int set_str0(zz_ptr a, unsigned char *nstr, unsigned char base, int part...
function set_str (line 839) | int set_str(zz_ptr a, unsigned char *nstr, B_int intbase) {
function B_bigint (line 927) | B_bigint $gcd(B_bigint a, B_bigint b) {
function B_tuple (line 933) | B_tuple $xgcd(B_bigint a, B_bigint b) {
type B_bigint (line 969) | struct B_bigint
FILE: base/builtin/bigint.h
type B_bigint (line 3) | struct B_bigint {
type B_bigint (line 21) | struct B_bigint
FILE: base/builtin/bool.c
function B_NoneType (line 19) | B_NoneType B_boolD___init__(B_bool self, B_value s){
function B_bool (line 24) | B_bool B_boolD___bool__(B_bool self) {
function B_str (line 28) | B_str B_boolD___str__(B_bool self) {
function B_str (line 35) | B_str B_boolD___repr__(B_bool self) {
function B_boolD___serialize__ (line 42) | void B_boolD___serialize__(B_bool self, $Serial$state state) {
function B_bool (line 46) | B_bool B_boolD___deserialize__(B_bool self, $Serial$state state) {
function B_bool (line 50) | B_bool B_boolG_new(B_value s) {
function B_bool (line 54) | B_bool toB_bool(long b) {
function fromB_bool (line 58) | long fromB_bool(B_bool b) {
type B_bool (line 62) | struct B_bool
type B_bool (line 63) | struct B_bool
function B_bool (line 69) | B_bool $default__bool__(B_value self) {
function B_bool (line 75) | B_bool B_HashableD_boolD___eq__(B_HashableD_bool wit, B_bool a, B_bool b) {
function B_bool (line 79) | B_bool B_HashableD_boolD___ne__(B_HashableD_bool wit, B_bool a, B_bool b) {
function B_NoneType (line 83) | B_NoneType B_HashableD_boolD_hash(B_HashableD_bool wit, B_bool a, B_hash...
FILE: base/builtin/bool.h
type B_bool (line 1) | struct B_bool {
FILE: base/builtin/box.c
function B_NoneType (line 15) | B_NoneType $BoxD___init__($Box self, $WORD val) {
function B_bool (line 20) | B_bool $BoxD___bool__($Box self) {
function B_str (line 25) | B_str $BoxD___str__($Box self) {
function B_str (line 30) | B_str $BoxD___repr__($Box self) {
function $BoxD___serialize__ (line 35) | void $BoxD___serialize__ ($Box self, $Serial$state state) {
function $Box (line 39) | $Box $BoxD___deserialize__ ($Box self, $Serial$state state) {
function $Box (line 52) | $Box $BoxG_new($WORD G_1) {
type $BoxG_class (line 59) | struct $BoxG_class
FILE: base/builtin/box.h
type $Box (line 1) | struct $Box
type $Box (line 3) | struct $Box
type $Box (line 5) | struct $Box {
type $BoxG_class (line 10) | struct $BoxG_class {
type $BoxG_class (line 24) | struct $BoxG_class
FILE: base/builtin/builtin.h
type B_NoneType (line 20) | struct B_NoneType
type B_NoneType (line 21) | struct B_NoneType
type B_tuple (line 23) | struct B_tuple
type B_tuple (line 24) | struct B_tuple
type $Serial$state (line 26) | struct $Serial$state
type $Serial$state (line 27) | struct $Serial$state
type $SuperG_class (line 29) | struct $SuperG_class
type $SuperG_class (line 30) | struct $SuperG_class
type $Super (line 32) | struct $Super
type $Super (line 33) | struct $Super
type $SerializableG_class (line 35) | struct $SerializableG_class
type $SerializableG_class (line 36) | struct $SerializableG_class
type $Serializable (line 38) | struct $Serializable
type $Serializable (line 39) | struct $Serializable
type $proc (line 43) | struct $proc
type $action (line 44) | struct $action
type $mut (line 45) | struct $mut
type $pure (line 46) | struct $pure
type $Cont (line 47) | struct $Cont
type $proc (line 49) | struct $proc
type $action (line 50) | struct $action
type $mut (line 51) | struct $mut
type $pure (line 52) | struct $pure
type $Cont (line 53) | struct $Cont
type $RTAG (line 55) | enum $RTAG { $RDONE, $RFAIL, $RCONT, $RWAIT }
type $RTAG (line 56) | typedef enum $RTAG $RTAG;
type $R (line 58) | struct $R {
type $R (line 63) | typedef struct $R $R;
type $Actor (line 74) | struct $Actor
type $Catcher (line 75) | struct $Catcher
type $Actor (line 76) | struct $Actor
type $Catcher (line 77) | struct $Catcher
FILE: base/builtin/builtin_functions.c
function $WORD (line 19) | static $WORD mkstr($WORD w) {
function B_str (line 42) | B_str __str__(B_value x) {
function B_NoneType (line 49) | B_NoneType B_print(B_tuple t, B_str sep_arg, B_str end_arg, B_bool stder...
function B_IteratorD_enumerate_init (line 93) | void B_IteratorD_enumerate_init(B_IteratorD_enumerate self, B_Iterator i...
function B_bool (line 98) | B_bool B_IteratorD_enumerate_bool(B_IteratorD_enumerate self) {
function B_str (line 102) | B_str B_IteratorD_enumerate_str(B_IteratorD_enumerate self) {
function B_IteratorD_enumerate_serialize (line 106) | void B_IteratorD_enumerate_serialize(B_IteratorD_enumerate self,$Serial$...
function B_IteratorD_enumerate (line 111) | B_IteratorD_enumerate B_IteratorD_enumerate$_deserialize(B_IteratorD_enu...
function $WORD (line 119) | $WORD B_IteratorD_enumerate_next(B_IteratorD_enumerate it) {
type B_IteratorD_enumerateG_class (line 124) | struct B_IteratorD_enumerateG_class
function B_IteratorD_enumerate (line 129) | B_IteratorD_enumerate B_IteratorD_enumerateG_new(B_Iterator it, B_int n) {
function B_Iterator (line 133) | B_Iterator B_enumerate(B_Iterable wit, $WORD iter, B_int start) {
function B_IteratorD_filter_init (line 142) | void B_IteratorD_filter_init(B_IteratorD_filter self, B_Iterator it, $p...
function B_bool (line 147) | B_bool B_IteratorD_filter_bool(B_IteratorD_filter self) {
function B_str (line 151) | B_str B_IteratorD_filter_str(B_IteratorD_filter self) {
function B_IteratorD_filter_serialize (line 155) | void B_IteratorD_filter_serialize(B_IteratorD_filter self,$Serial$state ...
function B_IteratorD_filter (line 159) | B_IteratorD_filter B_IteratorD_filter$_deserialize(B_IteratorD_filter re...
function $WORD (line 166) | $WORD B_IteratorD_filter_next(B_IteratorD_filter it) {
type B_IteratorD_filterG_class (line 174) | struct B_IteratorD_filterG_class
function B_IteratorD_filter (line 178) | B_IteratorD_filter B_IteratorD_filterG_new(B_Iterator it, $pure f) {
function B_Iterator (line 182) | B_Iterator B_filter(B_Iterable wit, $pure f, $WORD iter) {
function B_IteratorD_map_init (line 189) | void B_IteratorD_map_init(B_IteratorD_map self, B_Iterator it, $pure f) {
function B_bool (line 194) | B_bool B_IteratorD_map_bool(B_IteratorD_map self) {
function B_str (line 198) | B_str B_IteratorD_map_str(B_IteratorD_map self) {
function B_IteratorD_map_serialize (line 202) | void B_IteratorD_map_serialize(B_IteratorD_map self,$Serial$state state) {
function B_IteratorD_map (line 206) | B_IteratorD_map B_IteratorD_map$_deserialize(B_IteratorD_map res, $Seria...
function $WORD (line 213) | $WORD B_IteratorD_map_next(B_IteratorD_map it) {
type B_IteratorD_mapG_class (line 218) | struct B_IteratorD_mapG_class
function B_IteratorD_map (line 222) | B_IteratorD_map B_IteratorD_mapG_new(B_Iterator it, $pure f) {
function B_Iterator (line 226) | B_Iterator B_map(B_Iterable wit, $pure f, $WORD iter) {
function $WORD (line 234) | $WORD B_max(B_Ord wit, B_Iterable wit2, $WORD iter, $WORD dflt) {
function $WORD (line 264) | $WORD B_max_def(B_Ord wit, B_Iterable wit2, $WORD iter, $WORD dflt) {
function $WORD (line 284) | $WORD B_min(B_Ord wit, B_Iterable wit2, $WORD iter, $WORD dflt) {
function $WORD (line 314) | $WORD B_min_def(B_Ord wit, B_Iterable wit2, $WORD iter, $WORD dflt) {
function B_list (line 334) | B_list B_sorted(B_Ord wit, B_Iterable wit2, $WORD iter) {
function $WORD (line 343) | $WORD B_sum(B_Plus wit, B_Iterable wit2, $WORD iter, $WORD start) {
function B_IteratorD_zip_init (line 369) | void B_IteratorD_zip_init(B_IteratorD_zip self, B_Iterator it1, B_Iterat...
function B_bool (line 374) | B_bool B_IteratorD_zip_bool(B_IteratorD_zip self) {
function B_str (line 378) | B_str B_IteratorD_zip_str(B_IteratorD_zip self) {
function B_IteratorD_zip_serialize (line 382) | void B_IteratorD_zip_serialize(B_IteratorD_zip self,$Serial$state state) {
function B_IteratorD_zip (line 387) | B_IteratorD_zip B_IteratorD_zip$_deserialize(B_IteratorD_zip res, $Seria...
function $WORD (line 395) | $WORD B_IteratorD_zip_next(B_IteratorD_zip it) {
type B_IteratorD_zipG_class (line 401) | struct B_IteratorD_zipG_class
function B_IteratorD_zip (line 405) | B_IteratorD_zip B_IteratorD_zipG_new(B_Iterator iter1, B_Iterator iter2) {
function B_Iterator (line 410) | B_Iterator B_zip (B_Iterable wit1, B_Iterable wit2, $WORD iter1, $WORD i...
type $EqOptG_class (line 418) | struct $EqOptG_class
function $EqOptD___init__ (line 420) | void $EqOptD___init__($EqOpt wit, B_Eq W_Eq$A) {
function B_bool (line 424) | B_bool $EqOptD_bool($EqOpt self) {
function B_str (line 428) | B_str $EqOptD_str($EqOpt self) {
function $EqOptD_serialize (line 432) | void $EqOptD_serialize($EqOpt self,$Serial$state state) {
function $EqOpt (line 436) | $EqOpt $EqOptD_deserialize($EqOpt res, $Serial$state state) {
function B_bool (line 443) | B_bool $EqOptD___eq__($EqOpt wit, $WORD a, $WORD b) {
function B_bool (line 450) | B_bool $EqOptD___ne__($EqOpt wit, $WORD a, $WORD b) {
type $EqOptG_class (line 456) | struct $EqOptG_class
function $EqOpt (line 460) | $EqOpt $EqOptG_new(B_Eq W_Eq$A) {
type $IdentityActorG_class (line 467) | struct $IdentityActorG_class
function $IdentityActorD___init__ (line 469) | void $IdentityActorD___init__($IdentityActor wit) { }
function B_bool (line 471) | B_bool $IdentityActorD_bool($IdentityActor self) {
function B_str (line 475) | B_str $IdentityActorD_str($IdentityActor self) {
function $IdentityActorD_serialize (line 479) | void $IdentityActorD_serialize($IdentityActor self,$Serial$state state) { }
function $IdentityActor (line 481) | $IdentityActor $IdentityActorD_deserialize($IdentityActor res, $Serial$s...
function B_bool (line 487) | B_bool $IdentityActorD___is__($IdentityActor wit, $WORD a, $WORD b) {
function B_bool (line 491) | B_bool $IdentityActorD___isnot__($IdentityActor wit, $WORD a, $WORD b) {
type $IdentityActorG_class (line 495) | struct $IdentityActorG_class
function $IdentityActor (line 499) | $IdentityActor $IdentityActorG_new() {
function $WORD (line 563) | $WORD $ASSERT(B_bool test, B_str msg) {
FILE: base/builtin/builtin_functions.h
type B_IteratorD_enumerate (line 7) | struct B_IteratorD_enumerate
type B_IteratorD_enumerate (line 8) | struct B_IteratorD_enumerate
type B_IteratorD_enumerateG_class (line 10) | struct B_IteratorD_enumerateG_class {
type B_IteratorD_enumerate (line 23) | struct B_IteratorD_enumerate {
type B_IteratorD_enumerateG_class (line 29) | struct B_IteratorD_enumerateG_class
type B_IteratorD_filter (line 37) | struct B_IteratorD_filter
type B_IteratorD_filter (line 38) | struct B_IteratorD_filter
type B_IteratorD_filterG_class (line 40) | struct B_IteratorD_filterG_class {
type B_IteratorD_filter (line 53) | struct B_IteratorD_filter {
type B_IteratorD_filterG_class (line 59) | struct B_IteratorD_filterG_class
type B_IteratorD_map (line 66) | struct B_IteratorD_map
type B_IteratorD_map (line 67) | struct B_IteratorD_map
type B_IteratorD_mapG_class (line 69) | struct B_IteratorD_mapG_class {
type B_IteratorD_map (line 82) | struct B_IteratorD_map {
type B_IteratorD_mapG_class (line 88) | struct B_IteratorD_mapG_class
type B_IteratorD_zip (line 93) | struct B_IteratorD_zip
type B_IteratorD_zip (line 94) | struct B_IteratorD_zip
type B_IteratorD_zipG_class (line 96) | struct B_IteratorD_zipG_class {
type B_IteratorD_zip (line 109) | struct B_IteratorD_zip {
type B_IteratorD_zipG_class (line 115) | struct B_IteratorD_zipG_class
type $EqOpt (line 123) | struct $EqOpt
type $EqOpt (line 124) | struct $EqOpt
type $EqOptG_class (line 126) | struct $EqOptG_class {
type $EqOpt (line 140) | struct $EqOpt {
type $IdentityActor (line 150) | struct $IdentityActor
type $IdentityActor (line 151) | struct $IdentityActor
type $IdentityActorG_class (line 153) | struct $IdentityActorG_class {
type $IdentityActor (line 167) | struct $IdentityActor {
FILE: base/builtin/class_hierarchy.c
function $Serializable (line 15) | $Serializable $SerializableG_new() {
function B_NoneType (line 19) | B_NoneType $SerializableD___init__ ($Serializable self) {
function B_str (line 39) | B_str B_valueD___str__(B_value self) {
function B_str (line 43) | B_str B_valueD___repr__(B_value self) {
function B_str (line 47) | B_str B_objectD___str__(B_object self) {
function B_bool (line 51) | B_bool B_valueD___bool__(B_value self) {
function B_bool (line 54) | B_bool B_objectD___bool__(B_object self) {
type $SerializableG_class (line 58) | struct $SerializableG_class
FILE: base/builtin/class_hierarchy.h
type $SuperG_class (line 6) | struct $SuperG_class {
type $Super (line 12) | struct $Super {
type $SerializableG_class (line 38) | struct $SerializableG_class {
type $Serializable (line 47) | struct $Serializable {
type $SerializableG_class (line 51) | struct $SerializableG_class
FILE: base/builtin/common.c
function $default__init__ (line 15) | void $default__init__($WORD s) {
FILE: base/builtin/complex.c
function B_complex (line 15) | B_complex toB_complex(complex double c) {
function B_complex (line 22) | B_complex B_complexG_new(B_Number wit, $WORD c) {
function B_complex (line 26) | B_complex B_complexD_from_real_imag (B_Real wit1, B_Real wit2, $WORD rea...
function B_NoneType (line 32) | B_NoneType B_complexD___init__(B_complex self, B_Number wit, $WORD c){
function B_complexD___serialize__ (line 37) | void B_complexD___serialize__(B_complex c,$Serial$state state) {
function B_complex (line 45) | B_complex B_complexD___deserialize__(B_complex self, $Serial$state state) {
function B_bool (line 55) | B_bool B_complexD___bool__(B_complex n) {
function B_str (line 59) | B_str B_complexD___str__(B_complex c) {
function B_str (line 63) | B_str B_complexD___repr__(B_complex c) {
function B_complex (line 69) | B_complex B_NumberD_complexD___add__(B_NumberD_complex wit, B_complex a,...
function B_complex (line 73) | B_complex B_NumberD_complexD___zero__(B_NumberD_complex wit) {
function B_complex (line 77) | B_complex B_NumberD_complexD___complex__ (B_NumberD_complex wit, B_compl...
function B_complex (line 81) | B_complex B_NumberD_complexD___mul__ (B_NumberD_complex wit, B_complex a...
function B_complex (line 85) | B_complex B_NumberD_complexD___fromatom__(B_NumberD_complex wit, B_atom ...
function B_complex (line 90) | B_complex B_NumberD_complexD___pow__ (B_NumberD_complex wit, B_complex a...
function B_complex (line 94) | B_complex B_NumberD_complexD___neg__ (B_NumberD_complex wit, B_complex c){
function B_complex (line 98) | B_complex B_NumberD_complexD___pos__ (B_NumberD_complex wit, B_complex c) {
function $WORD (line 102) | $WORD B_NumberD_complexD_real (B_NumberD_complex wit, B_complex c, B_Rea...
function $WORD (line 106) | $WORD B_NumberD_complexD_imag (B_NumberD_complex wit, B_complex c, B_Rea...
function $WORD (line 110) | $WORD B_NumberD_complexD___abs__ (B_NumberD_complex wit, B_complex c, B_...
function B_complex (line 114) | B_complex B_NumberD_complexD_conjugate (B_NumberD_complex wit, B_complex...
function B_complex (line 120) | B_complex B_DivD_complexD___truediv__ (B_DivD_complex wit, B_complex a, ...
function B_complex (line 129) | B_complex B_MinusD_NumberD_complexD___sub__(B_MinusD_NumberD_complex wit...
function B_bool (line 134) | B_bool B_EqD_complexD___eq__ (B_EqD_complex wit, B_complex a, B_complex ...
function B_bool (line 138) | B_bool B_EqD_complexD___ne__ (B_EqD_complex wit, B_complex a, B_complex ...
function B_bool (line 145) | B_bool B_HashableD_complexD___eq__(B_HashableD_complex wit, B_complex a,...
function B_bool (line 149) | B_bool B_HashableD_complexD___ne__(B_HashableD_complex wit, B_complex a,...
function B_NoneType (line 153) | B_NoneType B_HashableD_complexD_hash(B_HashableD_complex wit, B_complex ...
FILE: base/builtin/complx.h
type B_complex (line 8) | struct B_complex {
FILE: base/builtin/csiphash.c
function siphash24 (line 82) | static uint64_t
FILE: base/builtin/dict.c
type $entry_struct (line 16) | struct $entry_struct {
type $table_struct (line 22) | struct $table_struct {
function build_indices (line 45) | static void build_indices(B_Hashable hashwit, $table oldtable, $table ne...
function dictresize (line 70) | static int dictresize(B_Hashable hashwit, B_dict d) {
function $lookdict_index (line 110) | static int $lookdict_index($table table, uint64_t hash, int index) {
function $lookdict (line 132) | int $lookdict(B_dict dict, B_Hashable hashwit, uint64_t hash, $WORD key,...
function find_empty_slot (line 183) | static long find_empty_slot($table table, uint64_t hash) {
function insertdict (line 197) | static void insertdict(B_dict dict, B_Hashable hashwit, uint64_t hash, $...
function B_dict (line 226) | B_dict B_dictG_new(B_Hashable hashwit, B_Iterable wit, $WORD iterable) {
function B_NoneType (line 230) | B_NoneType B_dictD___init__(B_dict dict, B_Hashable hashwit, B_Iterable ...
function B_bool (line 252) | B_bool B_dictD___bool__(B_dict self) {
function B_str (line 256) | B_str B_dictD___str__(B_dict self) {
function B_str (line 281) | B_str B_dictD___repr__(B_dict self) {
function B_dictD___serialize__ (line 285) | void B_dictD___serialize__(B_dict self,$Serial$state state) {
function B_dict (line 308) | B_dict B_dictD___deserialize__(B_dict res, $Serial$state state) {
function B_bool (line 338) | B_bool B_dictrel(bool directfalse,B_OrdD_dict w, B_dict a, B_dict b) {
function B_bool (line 371) | B_bool B_OrdD_dictD___eq__ (B_OrdD_dict w, B_dict a, B_dict b) {
function B_bool (line 375) | B_bool B_OrdD_dictD___ne__ (B_OrdD_dict w, B_dict a, B_dict b) {
function B_bool (line 379) | B_bool B_OrdD_dictD___lt__ (B_OrdD_dict w, B_dict a, B_dict b) {
function B_bool (line 383) | B_bool B_OrdD_dictD___le__ (B_OrdD_dict w, B_dict a, B_dict b) {
function B_bool (line 387) | B_bool B_OrdD_dictD___gt__ (B_OrdD_dict w, B_dict a, B_dict b) {
function B_bool (line 391) | B_bool B_OrdD_dictD___ge__ (B_OrdD_dict w, B_dict a, B_dict b) {
function $WORD (line 399) | static $WORD B_IteratorD_dictD_next(B_IteratorD_dict self) {
function B_IteratorD_dict (line 417) | B_IteratorD_dict B_IteratorD_dictG_new(B_dict dict) {
function B_IteratorD_dictD_init (line 421) | void B_IteratorD_dictD_init(B_IteratorD_dict self, B_dict dict) {
function B_bool (line 427) | B_bool B_IteratorD_dictD_bool(B_IteratorD_dict self) {
function B_str (line 431) | B_str B_IteratorD_dictD_str(B_IteratorD_dict self) {
function B_IteratorD_dictD_serialize (line 435) | void B_IteratorD_dictD_serialize(B_IteratorD_dict self, $Serial$state st...
function B_IteratorD_dict (line 441) | B_IteratorD_dict B_IteratorD_dict__deserialize(B_IteratorD_dict res, $Se...
type B_IteratorD_dictG_class (line 450) | struct B_IteratorD_dictG_class
function B_Iterator (line 454) | B_Iterator B_MappingD_dictD___iter__ (B_MappingD_dict wit, B_dict dict) {
function B_dict (line 458) | B_dict B_MappingD_dictD___fromiter__ (B_MappingD_dict wit, B_Iterable wi...
function B_int (line 472) | B_int B_MappingD_dictD___len__ (B_MappingD_dict wit, B_dict dict) {
function B_bool (line 476) | B_bool B_MappingD_dictD___contains__ (B_MappingD_dict wit, B_dict dict, ...
function B_bool (line 487) | B_bool B_MappingD_dictD___containsnot__ (B_MappingD_dict wit, B_dict dic...
function $WORD (line 491) | $WORD B_MappingD_dictD_get (B_MappingD_dict wit, B_dict dict, $WORD key) {
function $WORD (line 506) | $WORD B_MappingD_dictD_get_def (B_MappingD_dict wit, B_dict dict, $WORD ...
function $WORD (line 521) | $WORD B_MappingD_dictD_pop(B_MappingD_dict wit, B_dict dict, $WORD key) {
function $WORD (line 547) | $WORD B_MappingD_dictD_pop_def(B_MappingD_dict wit, B_dict dict, $WORD k...
function B_Iterator (line 573) | B_Iterator B_MappingD_dictD_keys (B_MappingD_dict wit, B_dict dict) {
function $WORD (line 581) | static $WORD B_IteratorD_dict_values_next(B_IteratorD_dict_values self) {
function B_IteratorD_dict_values (line 599) | B_IteratorD_dict_values B_IteratorD_dict_valuesG_new(B_dict dict) {
function B_IteratorD_dict_values_init (line 603) | void B_IteratorD_dict_values_init(B_IteratorD_dict_values self, B_dict d...
function B_bool (line 609) | B_bool B_IteratorD_dict_values_bool(B_IteratorD_dict_values self) {
function B_str (line 613) | B_str B_IteratorD_dict_values_str(B_IteratorD_dict_values self) {
function B_IteratorD_dict_values_serialize (line 617) | void B_IteratorD_dict_values_serialize(B_IteratorD_dict_values self, $Se...
function B_IteratorD_dict_values (line 622) | B_IteratorD_dict_values B_IteratorD_dict_values_deserialize(B_IteratorD_...
type B_IteratorD_dict_valuesG_class (line 630) | struct B_IteratorD_dict_valuesG_class
function $WORD (line 636) | static $WORD B_IteratorD_dict_items_next(B_IteratorD_dict_items self) {
function B_IteratorD_dict_items (line 654) | B_IteratorD_dict_items B_IteratorD_dict_itemsG_new(B_dict dict) {
function B_IteratorD_dict_items_init (line 658) | void B_IteratorD_dict_items_init(B_IteratorD_dict_items self, B_dict dic...
function B_bool (line 664) | B_bool B_IteratorD_dict_items_bool(B_IteratorD_dict_items self) {
function B_str (line 668) | B_str B_IteratorD_dict_items_str(B_IteratorD_dict_items self) {
function B_IteratorD_dict_items_serialize (line 672) | void B_IteratorD_dict_items_serialize(B_IteratorD_dict_items self, $Seri...
function B_IteratorD_dict_items (line 677) | B_IteratorD_dict_items B_IteratorD_dict_items_deserialize(B_IteratorD_di...
type B_IteratorD_dict_itemsG_class (line 687) | struct B_IteratorD_dict_itemsG_class
function B_Iterator (line 691) | B_Iterator B_MappingD_dictD_values (B_MappingD_dict wit, B_dict dict) {
function B_Iterator (line 695) | B_Iterator B_MappingD_dictD_items (B_MappingD_dict wit, B_dict dict) {
function B_NoneType (line 699) | B_NoneType B_MappingD_dictD_update (B_MappingD_dict wit, B_dict dict, B_...
function B_tuple (line 718) | B_tuple B_MappingD_dictD_popitem (B_MappingD_dict wit, B_dict dict) {
function $WORD (line 742) | $WORD B_MappingD_dictD_setdefault (B_MappingD_dict wit, B_dict dict, $WO...
function $WORD (line 757) | $WORD B_IndexedD_MappingD_dictD___getitem__(B_IndexedD_MappingD_dict wit...
function B_NoneType (line 773) | B_NoneType B_IndexedD_MappingD_dictD___setitem__ (B_IndexedD_MappingD_di...
function B_NoneType (line 783) | B_NoneType B_IndexedD_MappingD_dictD___delitem__ (B_IndexedD_MappingD_di...
function B_dictD_setitem (line 813) | void B_dictD_setitem(B_dict dict, B_Hashable hashwit, $WORD key, $WORD v...
function $WORD (line 821) | $WORD B_dictD_get(B_dict dict, B_Hashable hashwit, $WORD key, $WORD defl...
function $WORD (line 836) | $WORD B_dictD_pop(B_dict dict, B_Hashable hashwit, $WORD key, $WORD defl...
FILE: base/builtin/dict.h
type $table_struct (line 1) | struct $table_struct
type B_dict (line 3) | struct B_dict {
type B_IteratorD_dict (line 13) | struct B_IteratorD_dict
type B_IteratorD_dictG_class (line 15) | struct B_IteratorD_dictG_class {
type B_IteratorD_dict (line 28) | struct B_IteratorD_dict {
type B_IteratorD_dictG_class (line 34) | struct B_IteratorD_dictG_class
type B_IteratorD_dict_values (line 39) | struct B_IteratorD_dict_values
type B_IteratorD_dict_valuesG_class (line 41) | struct B_IteratorD_dict_valuesG_class {
type B_IteratorD_dict_values (line 54) | struct B_IteratorD_dict_values {
type B_IteratorD_dict_valuesG_class (line 60) | struct B_IteratorD_dict_valuesG_class
type B_IteratorD_dict_items (line 65) | struct B_IteratorD_dict_items
type B_IteratorD_dict_itemsG_class (line 67) | struct B_IteratorD_dict_itemsG_class {
type B_IteratorD_dict_items (line 80) | struct B_IteratorD_dict_items {
type B_IteratorD_dict_itemsG_class (line 86) | struct B_IteratorD_dict_itemsG_class
FILE: base/builtin/env.c
function $R (line 42) | $R B_EnvD_stdout_writeG_local (B_Env self, $Cont c$cont, B_str s) {
function $R (line 47) | $R B_EnvD_set_stdinG_local (B_Env self, $Cont c$cont, B_bool canonical, ...
function read_stdin (line 74) | void read_stdin(uv_stream_t *stream, ssize_t nread, const uv_buf_t *buf) {
function $R (line 87) | $R B_EnvD__on_stdin_bytesG_local (B_Env self, $Cont c$cont, $action cb) {
function $R (line 98) | $R B_EnvD_exitG_local (B_Env self, $Cont c$cont, B_int n) {
function B_Env (line 105) | B_Env B_EnvG_newactor(B_WorldCap wc, B_SysCap sc, B_list args) {
function B_SysCap (line 118) | B_SysCap B_SysCapG_new() {
function B_NoneType (line 125) | B_NoneType B_SysCapD___init__ (B_SysCap self) {
function B_WorldCap (line 130) | B_WorldCap B_WorldCapG_new() {
function B_NoneType (line 137) | B_NoneType B_WorldCapD___init__ (B_WorldCap self) {
FILE: base/builtin/exceptions.c
function B_NoneType (line 21) | B_NoneType $SEQD___init__ ($SEQ self) {
function $SEQ (line 25) | $SEQ $SEQD___deserialize__ ($SEQ self, $Serial$state state) {
function $SEQ (line 37) | $SEQ $SEQG_new() {
type $SEQG_class (line 43) | struct $SEQG_class
function $BRK (line 55) | $BRK $BRKD___deserialize__ ($BRK self, $Serial$state state) {
function $BRK (line 67) | $BRK $BRKG_new() {
type $BRKG_class (line 73) | struct $BRKG_class
function $CNT (line 85) | $CNT $CNTD___deserialize__ ($CNT self, $Serial$state state) {
function $CNT (line 97) | $CNT $CNTG_new() {
type $CNTG_class (line 103) | struct $CNTG_class
function B_NoneType (line 115) | B_NoneType $RETD___init__ ($RET self, B_value val) {
function $RETD___serialize__ (line 120) | void $RETD___serialize__ ($RET self, $Serial$state state) {
function $RET (line 123) | $RET $RETD___deserialize__ ($RET self, $Serial$state state) {
function $RET (line 136) | $RET $RETG_new(B_value G_1) {
type $RETG_class (line 142) | struct $RETG_class
function $WORD (line 154) | $WORD $raiseValueError(B_str msg) {
FILE: base/builtin/exceptions.h
type JumpBuf (line 3) | struct JumpBuf
type JumpBuf (line 4) | struct JumpBuf
type JumpBuf (line 5) | struct JumpBuf {
type $SEQ (line 97) | struct $SEQ
type $BRK (line 98) | struct $BRK
type $CNT (line 99) | struct $CNT
type $RET (line 100) | struct $RET
type $SEQ (line 102) | struct $SEQ
type $BRK (line 103) | struct $BRK
type $CNT (line 104) | struct $CNT
type $RET (line 105) | struct $RET
type $SEQG_class (line 107) | struct $SEQG_class {
type $SEQ (line 118) | struct $SEQ {
type $BRKG_class (line 122) | struct $BRKG_class {
type $BRK (line 133) | struct $BRK {
type $CNTG_class (line 137) | struct $CNTG_class {
type $CNT (line 148) | struct $CNT {
type $RETG_class (line 152) | struct $RETG_class {
type $RET (line 163) | struct $RET {
type $SEQG_class (line 169) | struct $SEQG_class
type $BRKG_class (line 170) | struct $BRKG_class
type $CNTG_class (line 171) | struct $CNTG_class
type $RETG_class (line 172) | struct $RETG_class
FILE: base/builtin/float.c
function B_float (line 19) | B_float B_floatG_new(B_atom a) {
function B_NoneType (line 56) | B_NoneType B_floatD___init__(B_float self, B_atom a){
function B_floatD___serialize__ (line 61) | void B_floatD___serialize__(B_float self, $Serial$state state) {
function B_float (line 65) | B_float B_floatD___deserialize__(B_float self, $Serial$state state) {
function B_bool (line 72) | B_bool B_floatD___bool__(B_float x) {
function B_str (line 76) | B_str B_floatD___str__(B_float x) {
function B_str (line 80) | B_str B_floatD___repr__(B_float x) {
function B_float (line 84) | B_float to$float(double x) {
function B_float (line 91) | B_float toB_float(double x) {
function fromB_float (line 98) | double fromB_float(B_float x) {
function B_float (line 105) | B_float B_RealFloatD_floatD___add__(B_RealFloatD_float wit, B_float a, ...
function B_float (line 109) | B_float B_RealFloatD_floatD___zero__(B_RealFloatD_float wit) {
function B_float (line 113) | B_float B_RealFloatD_floatD___fromatom__(B_RealFloatD_float wit, B_atom ...
function B_complex (line 117) | B_complex B_RealFloatD_floatD___complex__(B_RealFloatD_float wit, B_floa...
function B_float (line 121) | B_float B_RealFloatD_floatD___mul__(B_RealFloatD_float wit, B_float a, ...
function B_float (line 125) | B_float B_RealFloatD_floatD___pow__(B_RealFloatD_float wit, B_float a, ...
function B_float (line 129) | B_float B_RealFloatD_floatD___neg__(B_RealFloatD_float wit, B_float a) {
function B_float (line 133) | B_float B_RealFloatD_floatD___pos__(B_RealFloatD_float wit, B_float a) {
function $WORD (line 137) | $WORD B_RealFloatD_floatD_real(B_RealFloatD_float wit, B_float a, B_Real...
function $WORD (line 141) | $WORD B_RealFloatD_floatD_imag(B_RealFloatD_float wit, B_float a, B_Real...
function $WORD (line 145) | $WORD B_RealFloatD_floatD___abs__(B_RealFloatD_float wit, B_float a, B_R...
function B_float (line 149) | B_float B_RealFloatD_floatD_conjugate(B_RealFloatD_float wit, B_float a) {
function B_float (line 152) | B_float B_RealFloatD_floatD___float__ (B_RealFloatD_float wit, B_float x) {
function $WORD (line 156) | $WORD B_RealFloatD_floatD___trunc__ (B_RealFloatD_float wit, B_float x, ...
function $WORD (line 160) | $WORD B_RealFloatD_floatD___floor__ (B_RealFloatD_float wit, B_float x, ...
function $WORD (line 164) | $WORD B_RealFloatD_floatD___ceil__ (B_RealFloatD_float wit, B_float x, B...
function B_float (line 168) | B_float B_RealFloatD_floatD___round__ (B_RealFloatD_float wit, B_float x...
function B_float (line 177) | B_float B_MinusD_RealFloatD_floatD___sub__(B_MinusD_RealFloatD_float wit...
function B_float (line 183) | B_float B_DivD_floatD___truediv__(B_DivD_float wit, B_float a, B_float b) {
function B_bool (line 189) | B_bool B_OrdD_floatD___eq__ (B_OrdD_float wit, B_float a, B_float b) {
function B_bool (line 193) | B_bool B_OrdD_floatD___ne__ (B_OrdD_float wit, B_float a, B_float b) {
function B_bool (line 197) | B_bool B_OrdD_floatD___lt__ (B_OrdD_float wit, B_float a, B_float b) {
function B_bool (line 201) | B_bool B_OrdD_floatD___le__ (B_OrdD_float wit, B_float a, B_float b) {
function B_bool (line 205) | B_bool B_OrdD_floatD___gt__ (B_OrdD_float wit, B_float a, B_float b) {
function B_bool (line 209) | B_bool B_OrdD_floatD___ge__ (B_OrdD_float wit, B_float a, B_float b) {
function B_bool (line 216) | B_bool B_HashableD_floatD___eq__(B_HashableD_float wit, B_float a, B_flo...
function B_bool (line 220) | B_bool B_HashableD_floatD___neq__(B_HashableD_float wit, B_float a, B_fl...
function B_NoneType (line 224) | B_NoneType B_HashableD_floatD_hash(B_HashableD_float wit, B_float a, B_h...
FILE: base/builtin/float.h
type B_float (line 2) | struct B_float {
FILE: base/builtin/function.c
function B_bool (line 17) | B_bool $procD___bool__($proc self) {
function B_str (line 20) | B_str $procD___str__($proc self) {
function B_bool (line 24) | B_bool $actionD___bool__($action self) {
function B_str (line 27) | B_str $actionD___str__($action self) {
function B_bool (line 31) | B_bool $mutD___bool__($mut self) {
function B_str (line 34) | B_str $mutD___str__($mut self) {
function B_bool (line 38) | B_bool $pureD___bool__($pure self) {
function B_str (line 41) | B_str $pureD___str__($pure self) {
function $ContD___init__ (line 45) | void $ContD___init__($Cont $this) {
function B_bool (line 48) | B_bool $ContD___bool__($Cont self) {
function B_str (line 51) | B_str $ContD___str__($Cont self) {
function $ContD___serialize__ (line 54) | void $ContD___serialize__($Cont self, $Serial$state state) {
function $Cont (line 57) | $Cont $ContD___deserialize__($Cont self, $Serial$state state) {
type $ContG_class (line 61) | struct $ContG_class
type $procG_class (line 73) | struct $procG_class
type $actionG_class (line 86) | struct $actionG_class
type $mutG_class (line 100) | struct $mutG_class
type $pureG_class (line 114) | struct $pureG_class
FILE: base/builtin/function.h
type $ContG_class (line 3) | struct $ContG_class {
type $Cont (line 15) | struct $Cont {
type $ContG_class (line 18) | struct $ContG_class
type $procG_class (line 27) | struct $procG_class {
type $proc (line 40) | struct $proc {
type $procG_class (line 43) | struct $procG_class
type $actionG_class (line 46) | struct $actionG_class {
type $action (line 60) | struct $action {
type $actionG_class (line 63) | struct $actionG_class
type $mutG_class (line 66) | struct $mutG_class {
type $mut (line 80) | struct $mut {
type $mutG_class (line 83) | struct $mutG_class
type $pureG_class (line 86) | struct $pureG_class {
type $pure (line 100) | struct $pure {
type $pureG_class (line 103) | struct $pureG_class
type $action2 (line 107) | struct $action2
type $action2 (line 108) | struct $action2
type $action2G_class (line 109) | struct $action2G_class {
type $action2 (line 123) | struct $action2 {
type $action3 (line 127) | struct $action3
type $action3 (line 128) | struct $action3
type $action3G_class (line 129) | struct $action3G_class {
type $action3 (line 143) | struct $action3 {
FILE: base/builtin/hasher.c
function B_NoneType (line 1) | B_NoneType B_hasherD___init__ (B_hasher self, B_u64 seed) {
function B_NoneType (line 6) | B_NoneType B_hasherD_update (B_hasher self, B_bytes data) {
function B_u64 (line 11) | B_u64 B_hasherD_finalize (B_hasher self) {
function B_bool (line 17) | B_bool B_hasherD___bool__(B_hasher h) {
function B_str (line 21) | B_str B_hasherD___str__(B_hasher self) {
function B_str (line 25) | B_str B_hasherD___repr__(B_hasher self) {
function B_hasher (line 29) | B_hasher B_hasherG_new(B_u64 seed) {
function B_hasherD___serialize__ (line 33) | void B_hasherD___serialize__(B_hasher self, $Serial$state state) {
function B_hasher (line 37) | B_hasher B_hasherD___deserialize__(B_hasher self, $Serial$state state) {
FILE: base/builtin/hasher.h
type B_hasher (line 1) | struct B_hasher
type B_hasher (line 2) | struct B_hasher
type B_hasher (line 20) | struct B_hasher {
type B_hasherG_class (line 25) | struct B_hasherG_class
FILE: base/builtin/i16.c
function i16_pow (line 18) | short i16_pow(short a, short e) {
function B_i16 (line 27) | B_i16 B_i16G_new(B_atom a, B_int base) {
function B_NoneType (line 39) | B_NoneType B_i16D___init__(B_i16 self, B_atom a, B_int base){
function B_i16D___serialize__ (line 44) | void B_i16D___serialize__(B_i16 n, $Serial$state state) {
function B_i16 (line 48) | B_i16 B_i16D___deserialize__(B_i16 n, $Serial$state state) {
function B_bool (line 52) | B_bool B_i16D___bool__(B_i16 n) {
function B_str (line 56) | B_str B_i16D___str__(B_i16 n) {
function B_str (line 60) | B_str B_i16D___repr__(B_i16 n) {
function B_i16 (line 64) | B_i16 toB_i16(short i) {
function fromB_i16 (line 71) | short fromB_i16(B_i16 w) {
function B_i16 (line 80) | B_i16 B_IntegralD_i16D___add__(B_IntegralD_i16 wit, B_i16 a, B_i16 b) {
function B_i16 (line 84) | B_i16 B_IntegralD_i16D___zero__(B_IntegralD_i16 wit) {
function B_complex (line 88) | B_complex B_IntegralD_i16D___complex__(B_IntegralD_i16 wit, B_i16 a) {
function B_i16 (line 92) | B_i16 B_IntegralD_i16D___fromatom__(B_IntegralD_i16 wit, B_atom a) {
function B_i16 (line 96) | B_i16 B_IntegralD_i16D___mul__(B_IntegralD_i16 wit, B_i16 a, B_i16 b) {
function B_i16 (line 100) | B_i16 B_IntegralD_i16D___pow__(B_IntegralD_i16 wit, B_i16 a, B_i16 b) {
function B_i16 (line 108) | B_i16 B_IntegralD_i16D___neg__(B_IntegralD_i16 wit, B_i16 a) {
function B_i16 (line 112) | B_i16 B_IntegralD_i16D___pos__(B_IntegralD_i16 wit, B_i16 a) {
function $WORD (line 116) | $WORD B_IntegralD_i16D_real(B_IntegralD_i16 wit, B_i16 a, B_Real wit2) {
function $WORD (line 120) | $WORD B_IntegralD_i16D_imag(B_IntegralD_i16 wit, B_i16 a, B_Real wit2) {
function $WORD (line 124) | $WORD B_IntegralD_i16D___abs__(B_IntegralD_i16 wit, B_i16 a, B_Real wit2) {
function B_i16 (line 128) | B_i16 B_IntegralD_i16D_conjugate(B_IntegralD_i16 wit, B_i16 a) {
function B_float (line 132) | B_float B_IntegralD_i16D___float__ (B_IntegralD_i16 wit, B_i16 n) {
function $WORD (line 136) | $WORD B_IntegralD_i16D___trunc__ (B_IntegralD_i16 wit, B_i16 n, B_Integr...
function $WORD (line 140) | $WORD B_IntegralD_i16D___floor__ (B_IntegralD_i16 wit, B_i16 n, B_Integr...
function $WORD (line 144) | $WORD B_IntegralD_i16D___ceil__ (B_IntegralD_i16 wit, B_i16 n, B_Integra...
function B_i16 (line 148) | B_i16 B_IntegralD_i16D___round__ (B_IntegralD_i16 wit, B_i16 n, B_int p) {
function $WORD (line 162) | $WORD B_IntegralD_i16D_numerator (B_IntegralD_i16 wit, B_i16 n, B_Integr...
function $WORD (line 166) | $WORD B_IntegralD_i16D_denominator (B_IntegralD_i16 wit, B_i16 n, B_Inte...
function B_int (line 170) | B_int B_IntegralD_i16D___int__ (B_IntegralD_i16 wit, B_i16 n) {
function B_int (line 174) | B_int B_IntegralD_i16D___index__(B_IntegralD_i16 wit, B_i16 n) {
function B_tuple (line 178) | B_tuple B_IntegralD_i16D___divmod__(B_IntegralD_i16 wit, B_i16 a, B_i16 ...
function B_i16 (line 186) | B_i16 B_IntegralD_i16D___floordiv__(B_IntegralD_i16 wit, B_i16 a, B_i16 ...
function B_i16 (line 192) | B_i16 B_IntegralD_i16D___mod__(B_IntegralD_i16 wit, B_i16 a, B_i16 b) {
function B_i16 (line 196) | B_i16 B_IntegralD_i16D___lshift__(B_IntegralD_i16 wit, B_i16 a, B_int b) {
function B_i16 (line 200) | B_i16 B_IntegralD_i16D___rshift__(B_IntegralD_i16 wit, B_i16 a, B_int b) {
function B_i16 (line 204) | B_i16 B_IntegralD_i16D___invert__(B_IntegralD_i16 wit, B_i16 a) {
function B_i16 (line 211) | B_i16 B_LogicalD_IntegralD_i16D___and__(B_LogicalD_IntegralD_i16 wit, B...
function B_i16 (line 215) | B_i16 B_LogicalD_IntegralD_i16D___or__(B_LogicalD_IntegralD_i16 wit, B_...
function B_i16 (line 219) | B_i16 B_LogicalD_IntegralD_i16D___xor__(B_LogicalD_IntegralD_i16 wit, B...
function B_i16 (line 226) | B_i16 B_MinusD_IntegralD_i16D___sub__(B_MinusD_IntegralD_i16 wit, B_i16...
function B_float (line 233) | B_float B_DivD_i16D___truediv__ (B_DivD_i16 wit, B_i16 a, B_i16 b) {
function B_bool (line 241) | B_bool B_OrdD_i16D___eq__ (B_OrdD_i16 wit, B_i16 a, B_i16 b) {
function B_bool (line 245) | B_bool B_OrdD_i16D___ne__ (B_OrdD_i16 wit, B_i16 a, B_i16 b) {
function B_bool (line 249) | B_bool B_OrdD_i16D___lt__ (B_OrdD_i16 wit, B_i16 a, B_i16 b) {
function B_bool (line 253) | B_bool B_OrdD_i16D___le__ (B_OrdD_i16 wit, B_i16 a, B_i16 b) {
function B_bool (line 257) | B_bool B_OrdD_i16D___gt__ (B_OrdD_i16 wit, B_i16 a, B_i16 b) {
function B_bool (line 261) | B_bool B_OrdD_i16D___ge__ (B_OrdD_i16 wit, B_i16 a, B_i16 b) {
function B_bool (line 267) | B_bool B_HashableD_i16D___eq__(B_HashableD_i16 wit, B_i16 a, B_i16 b) {
function B_bool (line 271) | B_bool B_HashableD_i16D___ne__(B_HashableD_i16 wit, B_i16 a, B_i16 b) {
function B_NoneType (line 275) | B_NoneType B_HashableD_i16D_hash(B_HashableD_i16 wit, B_i16 a, B_hasher ...
FILE: base/builtin/i16.h
type B_i16 (line 1) | struct B_i16 {
FILE: base/builtin/i32.c
function i32_pow (line 18) | int i32_pow(int a, int e) {
function B_i32 (line 27) | B_i32 B_i32G_new(B_atom a, B_int base) {
function B_NoneType (line 40) | B_NoneType B_i32D___init__(B_i32 self, B_atom a, B_int base){
function B_i32D___serialize__ (line 45) | void B_i32D___serialize__(B_i32 n, $Serial$state state) {
function B_i32 (line 49) | B_i32 B_i32D___deserialize__(B_i32 n, $Serial$state state) {
function B_bool (line 53) | B_bool B_i32D___bool__(B_i32 n) {
function B_str (line 57) | B_str B_i32D___str__(B_i32 n) {
function B_str (line 61) | B_str B_i32D___repr__(B_i32 n) {
function B_i32 (line 65) | B_i32 toB_i32(int i) {
function fromB_i32 (line 72) | int fromB_i32(B_i32 w) {
function B_i32 (line 81) | B_i32 B_IntegralD_i32D___add__(B_IntegralD_i32 wit, B_i32 a, B_i32 b) {
function B_i32 (line 85) | B_i32 B_IntegralD_i32D___zero__(B_IntegralD_i32 wit) {
function B_complex (line 89) | B_complex B_IntegralD_i32D___complex__(B_IntegralD_i32 wit, B_i32 a) {
function B_i32 (line 93) | B_i32 B_IntegralD_i32D___fromatom__(B_IntegralD_i32 wit, B_atom a) {
function B_i32 (line 97) | B_i32 B_IntegralD_i32D___mul__(B_IntegralD_i32 wit, B_i32 a, B_i32 b) {
function B_i32 (line 101) | B_i32 B_IntegralD_i32D___pow__(B_IntegralD_i32 wit, B_i32 a, B_i32 b) {
function B_i32 (line 109) | B_i32 B_IntegralD_i32D___neg__(B_IntegralD_i32 wit, B_i32 a) {
function B_i32 (line 113) | B_i32 B_IntegralD_i32D___pos__(B_IntegralD_i32 wit, B_i32 a) {
function $WORD (line 117) | $WORD B_IntegralD_i32D_real(B_IntegralD_i32 wit, B_i32 a, B_Real wit2) {
function $WORD (line 121) | $WORD B_IntegralD_i32D_imag(B_IntegralD_i32 wit, B_i32 a, B_Real wit2) {
function $WORD (line 125) | $WORD B_IntegralD_i32D___abs__(B_IntegralD_i32 wit, B_i32 a, B_Real wit2) {
function B_i32 (line 129) | B_i32 B_IntegralD_i32D_conjugate(B_IntegralD_i32 wit, B_i32 a) {
function B_float (line 133) | B_float B_IntegralD_i32D___float__ (B_IntegralD_i32 wit, B_i32 n) {
function $WORD (line 137) | $WORD B_IntegralD_i32D___trunc__ (B_IntegralD_i32 wit, B_i32 n, B_Integr...
function $WORD (line 141) | $WORD B_IntegralD_i32D___floor__ (B_IntegralD_i32 wit, B_i32 n, B_Integr...
function $WORD (line 145) | $WORD B_IntegralD_i32D___ceil__ (B_IntegralD_i32 wit, B_i32 n, B_Integra...
function B_i32 (line 149) | B_i32 B_IntegralD_i32D___round__ (B_IntegralD_i32 wit, B_i32 n, B_int p) {
function $WORD (line 163) | $WORD B_IntegralD_i32D_numerator (B_IntegralD_i32 wit, B_i32 n, B_Integr...
function $WORD (line 167) | $WORD B_IntegralD_i32D_denominator (B_IntegralD_i32 wit, B_i32 n, B_Inte...
function B_int (line 171) | B_int B_IntegralD_i32D___int__ (B_IntegralD_i32 wit, B_i32 n) {
function B_int (line 175) | B_int B_IntegralD_i32D___index__(B_IntegralD_i32 wit, B_i32 n) {
function B_tuple (line 179) | B_tuple B_IntegralD_i32D___divmod__(B_IntegralD_i32 wit, B_i32 a, B_i32 ...
function B_i32 (line 185) | B_i32 B_IntegralD_i32D___floordiv__(B_IntegralD_i32 wit, B_i32 a, B_i32 ...
function B_i32 (line 191) | B_i32 B_IntegralD_i32D___mod__(B_IntegralD_i32 wit, B_i32 a, B_i32 b) {
function B_i32 (line 195) | B_i32 B_IntegralD_i32D___lshift__(B_IntegralD_i32 wit, B_i32 a, B_int b) {
function B_i32 (line 199) | B_i32 B_IntegralD_i32D___rshift__(B_IntegralD_i32 wit, B_i32 a, B_int b) {
function B_i32 (line 203) | B_i32 B_IntegralD_i32D___invert__(B_IntegralD_i32 wit, B_i32 a) {
function B_i32 (line 210) | B_i32 B_LogicalD_IntegralD_i32D___and__(B_LogicalD_IntegralD_i32 wit, B...
function B_i32 (line 214) | B_i32 B_LogicalD_IntegralD_i32D___or__(B_LogicalD_IntegralD_i32 wit, B_...
function B_i32 (line 218) | B_i32 B_LogicalD_IntegralD_i32D___xor__(B_LogicalD_IntegralD_i32 wit, B...
function B_i32 (line 225) | B_i32 B_MinusD_IntegralD_i32D___sub__(B_MinusD_IntegralD_i32 wit, B_i32...
function B_float (line 232) | B_float B_DivD_i32D___truediv__ (B_DivD_i32 wit, B_i32 a, B_i32 b) {
function B_bool (line 240) | B_bool B_OrdD_i32D___eq__ (B_OrdD_i32 wit, B_i32 a, B_i32 b) {
function B_bool (line 244) | B_bool B_OrdD_i32D___ne__ (B_OrdD_i32 wit, B_i32 a, B_i32 b) {
function B_bool (line 248) | B_bool B_OrdD_i32D___lt__ (B_OrdD_i32 wit, B_i32 a, B_i32 b) {
function B_bool (line 252) | B_bool B_OrdD_i32D___le__ (B_OrdD_i32 wit, B_i32 a, B_i32 b) {
function B_bool (line 256) | B_bool B_OrdD_i32D___gt__ (B_OrdD_i32 wit, B_i32 a, B_i32 b) {
function B_bool (line 260) | B_bool B_OrdD_i32D___ge__ (B_OrdD_i32 wit, B_i32 a, B_i32 b) {
function B_bool (line 266) | B_bool B_HashableD_i32D___eq__(B_HashableD_i32 wit, B_i32 a, B_i32 b) {
function B_bool (line 270) | B_bool B_HashableD_i32D___ne__(B_HashableD_i32 wit, B_i32 a, B_i32 b) {
function B_NoneType (line 274) | B_NoneType B_HashableD_i32D_hash(B_HashableD_i32 wit, B_i32 a, B_hasher ...
FILE: base/builtin/i32.h
type B_i32 (line 1) | struct B_i32 {
FILE: base/builtin/i8.c
function i8_pow (line 18) | int8_t i8_pow(int8_t a, int8_t e) {
function B_i8 (line 27) | B_i8 B_i8G_new(B_atom a, B_int base) {
function B_NoneType (line 39) | B_NoneType B_i8D___init__(B_i8 self, B_atom a, B_int base){
function B_i8D___serialize__ (line 44) | void B_i8D___serialize__(B_i8 n, $Serial$state state) {
function B_i8 (line 48) | B_i8 B_i8D___deserialize__(B_i8 n, $Serial$state state) {
function B_bool (line 52) | B_bool B_i8D___bool__(B_i8 n) {
function B_str (line 56) | B_str B_i8D___str__(B_i8 n) {
function B_str (line 60) | B_str B_i8D___repr__(B_i8 n) {
function B_i8 (line 64) | B_i8 toB_i8(int8_t i) {
function fromB_i8 (line 71) | int8_t fromB_i8(B_i8 w) {
function B_i8 (line 80) | B_i8 B_IntegralD_i8D___add__(B_IntegralD_i8 wit, B_i8 a, B_i8 b) {
function B_i8 (line 84) | B_i8 B_IntegralD_i8D___zero__(B_IntegralD_i8 wit) {
function B_complex (line 88) | B_complex B_IntegralD_i8D___complex__(B_IntegralD_i8 wit, B_i8 a) {
function B_i8 (line 92) | B_i8 B_IntegralD_i8D___fromatom__(B_IntegralD_i8 wit, B_atom a) {
function B_i8 (line 96) | B_i8 B_IntegralD_i8D___mul__(B_IntegralD_i8 wit, B_i8 a, B_i8 b) {
function B_i8 (line 100) | B_i8 B_IntegralD_i8D___pow__(B_IntegralD_i8 wit, B_i8 a, B_i8 b) {
function B_i8 (line 108) | B_i8 B_IntegralD_i8D___neg__(B_IntegralD_i8 wit, B_i8 a) {
function B_i8 (line 112) | B_i8 B_IntegralD_i8D___pos__(B_IntegralD_i8 wit, B_i8 a) {
function $WORD (line 116) | $WORD B_IntegralD_i8D_real(B_IntegralD_i8 wit, B_i8 a, B_Real wit2) {
function $WORD (line 120) | $WORD B_IntegralD_i8D_imag(B_IntegralD_i8 wit, B_i8 a, B_Real wit2) {
function $WORD (line 124) | $WORD B_IntegralD_i8D___abs__(B_IntegralD_i8 wit, B_i8 a, B_Real wit2) {
function B_i8 (line 128) | B_i8 B_IntegralD_i8D_conjugate(B_IntegralD_i8 wit, B_i8 a) {
function B_float (line 132) | B_float B_IntegralD_i8D___float__ (B_IntegralD_i8 wit, B_i8 n) {
function $WORD (line 136) | $WORD B_IntegralD_i8D___trunc__ (B_IntegralD_i8 wit, B_i8 n, B_Integral ...
function $WORD (line 140) | $WORD B_IntegralD_i8D___floor__ (B_IntegralD_i8 wit, B_i8 n, B_Integral ...
function $WORD (line 144) | $WORD B_IntegralD_i8D___ceil__ (B_IntegralD_i8 wit, B_i8 n, B_Integral w...
function B_i8 (line 148) | B_i8 B_IntegralD_i8D___round__ (B_IntegralD_i8 wit, B_i8 n, B_int p) {
function $WORD (line 162) | $WORD B_IntegralD_i8D_numerator (B_IntegralD_i8 wit, B_i8 n, B_Integral ...
function $WORD (line 166) | $WORD B_IntegralD_i8D_denominator (B_IntegralD_i8 wit, B_i8 n, B_Integra...
function B_int (line 170) | B_int B_IntegralD_i8D___int__ (B_IntegralD_i8 wit, B_i8 n) {
function B_int (line 174) | B_int B_IntegralD_i8D___index__(B_IntegralD_i8 wit, B_i8 n) {
function B_tuple (line 178) | B_tuple B_IntegralD_i8D___divmod__(B_IntegralD_i8 wit, B_i8 a, B_i8 b) {
function B_i8 (line 186) | B_i8 B_IntegralD_i8D___floordiv__(B_IntegralD_i8 wit, B_i8 a, B_i8 b) {
function B_i8 (line 192) | B_i8 B_IntegralD_i8D___mod__(B_IntegralD_i8 wit, B_i8 a, B_i8 b) {
function B_i8 (line 196) | B_i8 B_IntegralD_i8D___lshift__(B_IntegralD_i8 wit, B_i8 a, B_int b) {
function B_i8 (line 200) | B_i8 B_IntegralD_i8D___rshift__(B_IntegralD_i8 wit, B_i8 a, B_int b) {
function B_i8 (line 204) | B_i8 B_IntegralD_i8D___invert__(B_IntegralD_i8 wit, B_i8 a) {
function B_i8 (line 211) | B_i8 B_LogicalD_IntegralD_i8D___and__(B_LogicalD_IntegralD_i8 wit, B_i8...
function B_i8 (line 215) | B_i8 B_LogicalD_IntegralD_i8D___or__(B_LogicalD_IntegralD_i8 wit, B_i8 ...
function B_i8 (line 219) | B_i8 B_LogicalD_IntegralD_i8D___xor__(B_LogicalD_IntegralD_i8 wit, B_i8...
function B_i8 (line 226) | B_i8 B_MinusD_IntegralD_i8D___sub__(B_MinusD_IntegralD_i8 wit, B_i8 a, ...
function B_float (line 233) | B_float B_DivD_i8D___truediv__ (B_DivD_i8 wit, B_i8 a, B_i8 b) {
function B_bool (line 241) | B_bool B_OrdD_i8D___eq__ (B_OrdD_i8 wit, B_i8 a, B_i8 b) {
function B_bool (line 245) | B_bool B_OrdD_i8D___ne__ (B_OrdD_i8 wit, B_i8 a, B_i8 b) {
function B_bool (line 249) | B_bool B_OrdD_i8D___lt__ (B_OrdD_i8 wit, B_i8 a, B_i8 b) {
function B_bool (line 253) | B_bool B_OrdD_i8D___le__ (B_OrdD_i8 wit, B_i8 a, B_i8 b) {
function B_bool (line 257) | B_bool B_OrdD_i8D___gt__ (B_OrdD_i8 wit, B_i8 a, B_i8 b) {
function B_bool (line 261) | B_bool B_OrdD_i8D___ge__ (B_OrdD_i8 wit, B_i8 a, B_i8 b) {
function B_bool (line 267) | B_bool B_HashableD_i8D___eq__(B_HashableD_i8 wit, B_i8 a, B_i8 b) {
function B_bool (line 271) | B_bool B_HashableD_i8D___ne__(B_HashableD_i8 wit, B_i8 a, B_i8 b) {
function B_NoneType (line 275) | B_NoneType B_HashableD_i8D_hash(B_HashableD_i8 wit, B_i8 a, B_hasher h) {
FILE: base/builtin/i8.h
type B_i8 (line 1) | struct B_i8 {
FILE: base/builtin/int.c
function int_pow (line 18) | long int_pow(long a, long e) {
function B_int (line 27) | B_int B_intG_new(B_atom a, B_int base) {
function B_NoneType (line 39) | B_NoneType B_intD___init__(B_int self, B_atom a, B_int base){
function B_intD___serialize__ (line 44) | void B_intD___serialize__(B_int n, $Serial$state state) {
function B_int (line 48) | B_int B_intD___deserialize__(B_int n, $Serial$state state) {
function B_bool (line 52) | B_bool B_intD___bool__(B_int n) {
function B_str (line 56) | B_str B_intD___str__(B_int n) {
function B_str (line 60) | B_str B_intD___repr__(B_int n) {
function B_int (line 64) | B_int toB_int(int64_t i) {
function B_int (line 71) | B_int to$int(int64_t n) {
function fromB_int (line 75) | int64_t fromB_int(B_int w) {
function B_int (line 84) | B_int B_IntegralD_intD___add__(B_IntegralD_int wit, B_int a, B_int b) {
function B_int (line 88) | B_int B_IntegralD_intD___zero__(B_IntegralD_int wit) {
function B_complex (line 92) | B_complex B_IntegralD_intD___complex__(B_IntegralD_int wit, B_int a) {
function B_int (line 96) | B_int B_IntegralD_intD___fromatom__(B_IntegralD_int wit, B_atom a) {
function B_int (line 100) | B_int B_IntegralD_intD___mul__(B_IntegralD_int wit, B_int a, B_int b) {
function B_int (line 104) | B_int B_IntegralD_intD___pow__(B_IntegralD_int wit, B_int a, B_int b) {
function B_int (line 112) | B_int B_IntegralD_intD___neg__(B_IntegralD_int wit, B_int a) {
function B_int (line 116) | B_int B_IntegralD_intD___pos__(B_IntegralD_int wit, B_int a) {
function $WORD (line 120) | $WORD B_IntegralD_intD_real(B_IntegralD_int wit, B_int a, B_Real wit2) {
function $WORD (line 124) | $WORD B_IntegralD_intD_imag(B_IntegralD_int wit, B_int a, B_Real wit2) {
function $WORD (line 128) | $WORD B_IntegralD_intD___abs__(B_IntegralD_int wit, B_int a, B_Real wit2) {
function B_int (line 132) | B_int B_IntegralD_intD_conjugate(B_IntegralD_int wit, B_int a) {
function B_float (line 136) | B_float B_IntegralD_intD___float__ (B_IntegralD_int wit, B_int n) {
function $WORD (line 140) | $WORD B_IntegralD_intD___trunc__ (B_IntegralD_int wit, B_int n, B_Integr...
function $WORD (line 144) | $WORD B_IntegralD_intD___floor__ (B_IntegralD_int wit, B_int n, B_Integr...
function $WORD (line 148) | $WORD B_IntegralD_intD___ceil__ (B_IntegralD_int wit, B_int n, B_Integra...
function B_int (line 152) | B_int B_IntegralD_intD___round__ (B_IntegralD_int wit, B_int n, B_int p) {
function $WORD (line 166) | $WORD B_IntegralD_intD_numerator (B_IntegralD_int wit, B_int n, B_Integr...
function $WORD (line 170) | $WORD B_IntegralD_intD_denominator (B_IntegralD_int wit, B_int n, B_Inte...
function B_int (line 174) | B_int B_IntegralD_intD___int__ (B_IntegralD_int wit, B_int n) {
function B_int (line 178) | B_int B_IntegralD_intD___index__(B_IntegralD_int wit, B_int n) {
function B_tuple (line 182) | B_tuple B_IntegralD_intD___divmod__(B_IntegralD_int wit, B_int a, B_int ...
function B_int (line 188) | B_int B_IntegralD_intD___floordiv__(B_IntegralD_int wit, B_int a, B_int ...
function B_int (line 194) | B_int B_IntegralD_intD___mod__(B_IntegralD_int wit, B_int a, B_int b) {
function B_int (line 198) | B_int B_IntegralD_intD___lshift__(B_IntegralD_int wit, B_int a, B_int b) {
function B_int (line 202) | B_int B_IntegralD_intD___rshift__(B_IntegralD_int wit, B_int a, B_int b) {
function B_int (line 206) | B_int B_IntegralD_intD___invert__(B_IntegralD_int wit, B_int a) {
function B_int (line 213) | B_int B_LogicalD_IntegralD_intD___and__(B_LogicalD_IntegralD_int wit, B...
function B_int (line 217) | B_int B_LogicalD_IntegralD_intD___or__(B_LogicalD_IntegralD_int wit, B_...
function B_int (line 221) | B_int B_LogicalD_IntegralD_intD___xor__(B_LogicalD_IntegralD_int wit, B...
function B_int (line 228) | B_int B_MinusD_IntegralD_intD___sub__(B_MinusD_IntegralD_int wit, B_int...
function B_float (line 235) | B_float B_DivD_intD___truediv__ (B_DivD_int wit, B_int a, B_int b) {
function B_bool (line 243) | B_bool B_OrdD_intD___eq__ (B_OrdD_int wit, B_int a, B_int b) {
function B_bool (line 247) | B_bool B_OrdD_intD___ne__ (B_OrdD_int wit, B_int a, B_int b) {
function B_bool (line 251) | B_bool B_OrdD_intD___lt__ (B_OrdD_int wit, B_int a, B_int b) {
function B_bool (line 255) | B_bool B_OrdD_intD___le__ (B_OrdD_int wit, B_int a, B_int b) {
function B_bool (line 259) | B_bool B_OrdD_intD___gt__ (B_OrdD_int wit, B_int a, B_int b) {
function B_bool (line 263) | B_bool B_OrdD_intD___ge__ (B_OrdD_int wit, B_int a, B_int b) {
function B_bool (line 269) | B_bool B_HashableD_intD___eq__(B_HashableD_int wit, B_int a, B_int b) {
function B_bool (line 273) | B_bool B_HashableD_intD___ne__(B_HashableD_int wit, B_int a, B_int b) {
function B_NoneType (line 277) | B_NoneType B_HashableD_intD_hash(B_HashableD_int wit, B_int a, B_hasher ...
FILE: base/builtin/int.h
type B_int (line 1) | struct B_int {
FILE: base/builtin/list.c
function expand (line 18) | static void expand(B_list lst, int n) {
function shrink (line 34) | static void shrink(B_list lst) {
function B_list (line 46) | B_list B_listD_new(int capacity) {
function B_list (line 71) | B_list B_listG_new(B_Iterable wit, $WORD iterable) {
function B_NoneType (line 75) | B_NoneType B_listD___init__(B_list lst, B_Iterable wit, $WORD iterable) {
function B_bool (line 101) | B_bool B_listD___bool__(B_list self) {
function B_str (line 105) | B_str B_listD___str__(B_list self) {
function B_str (line 119) | B_str B_listD___repr__(B_list self) {
function B_listD___serialize__ (line 123) | void B_listD___serialize__(B_list self,$Serial$state state) {
function B_list (line 138) | B_list B_listD___deserialize__(B_list res, $Serial$state state) {
function B_list (line 155) | B_list B_listD_copy(B_list lst) {
function B_NoneType (line 164) | B_NoneType B_listD_clear(B_list lst) {
function B_NoneType (line 171) | B_NoneType B_listD_extend(B_list lst, B_list other) {
function $WORD (line 180) | $WORD B_listD_pop(B_list lst, B_int i) {
function B_int (line 201) | B_int B_listD_index(B_list self, B_Eq W_EqD_B, $WORD val, B_int start, B...
function B_int (line 227) | B_int B_listD_count(B_list self, B_Eq W_EqD_B, $WORD val) {
function B_bool (line 242) | B_bool B_OrdD_listD___eq__ (B_OrdD_list w, B_list a, B_list b) {
function B_bool (line 251) | B_bool B_OrdD_listD___ne__ (B_OrdD_list w, B_list a, B_list b) {
function B_bool (line 255) | B_bool B_OrdD_listD___lt__ (B_OrdD_list w, B_list a, B_list b) {
function B_bool (line 267) | B_bool B_OrdD_listD___le__ (B_OrdD_list w, B_list a, B_list b) {
function B_bool (line 279) | B_bool B_OrdD_listD___gt__ (B_OrdD_list w, B_list a, B_list b) {
function B_bool (line 283) | B_bool B_OrdD_listD___ge__ (B_OrdD_list w, B_list a, B_list b) {
function B_list (line 291) | B_list B_TimesD_SequenceD_listD___add__ (B_TimesD_SequenceD_list wit, B_...
function B_list (line 304) | B_list B_TimesD_SequenceD_listD___zero__ (B_TimesD_SequenceD_list wit) {
function B_list (line 308) | B_list B_TimesD_SequenceD_listD___mul__ (B_TimesD_SequenceD_list wit, B_...
function $WORD (line 327) | static $WORD B_IteratorD_listD_next(B_IteratorD_list self) {
function B_IteratorD_list (line 333) | B_IteratorD_list B_IteratorD_listG_new(B_list lst) {
function B_IteratorD_listD_init (line 337) | void B_IteratorD_listD_init(B_IteratorD_list self, B_list lst) {
function B_bool (line 342) | B_bool B_IteratorD_listD_bool(B_IteratorD_list self) {
function B_str (line 346) | B_str B_IteratorD_listD_str(B_IteratorD_list self) {
function B_IteratorD_listD_serialize (line 350) | void B_IteratorD_listD_serialize(B_IteratorD_list self,$Serial$state sta...
function B_IteratorD_list (line 355) | B_IteratorD_list B_IteratorD_list$_deserialize(B_IteratorD_list res, $Se...
type B_IteratorD_listG_class (line 363) | struct B_IteratorD_listG_class
function B_Iterator (line 368) | B_Iterator B_CollectionD_SequenceD_listD___iter__(B_CollectionD_Sequence...
function B_list (line 372) | B_list B_CollectionD_SequenceD_listD___fromiter__ (B_CollectionD_Sequenc...
function B_int (line 386) | B_int B_CollectionD_SequenceD_listD___len__(B_CollectionD_SequenceD_list...
function $WORD (line 392) | $WORD $listD_U__getitem__(B_list lst, int64_t n) {
function $WORD (line 401) | $WORD B_SequenceD_listD___getitem__(B_SequenceD_list wit, B_list lst, B_...
function B_NoneType (line 405) | B_NoneType listD_U__setitem__(B_list lst, int64_t n, $WORD val) {
function B_NoneType (line 415) | B_NoneType B_SequenceD_listD___setitem__(B_SequenceD_list wit, B_list ls...
function B_NoneType (line 419) | B_NoneType B_SequenceD_listD___delitem__(B_SequenceD_list wit, B_list ls...
function B_list (line 438) | B_list B_SequenceD_listD___getslice__(B_SequenceD_list wit, B_list lst, ...
function B_NoneType (line 453) | B_NoneType B_SequenceD_listD___setslice__(B_SequenceD_list wit, B_list l...
function B_NoneType (line 506) | B_NoneType B_SequenceD_listD___delslice__(B_SequenceD_list wit, B_list l...
function B_NoneType (line 521) | B_NoneType B_SequenceD_listD_reverse(B_SequenceD_list wit, B_list lst) {
function B_Iterator (line 531) | B_Iterator B_SequenceD_listD___reversed__(B_SequenceD_list wit, B_list l...
function B_NoneType (line 537) | B_NoneType B_SequenceD_listD_insert(B_SequenceD_list wit, B_list lst, B_...
function B_NoneType (line 550) | B_NoneType B_SequenceD_listD_append(B_SequenceD_list wit, B_list lst, $W...
function B_bool (line 559) | B_bool B_ContainerD_listD___contains__(B_ContainerD_list wit, B_list lst...
function B_bool (line 572) | B_bool B_ContainerD_listD___containsnot__(B_ContainerD_list wit, B_list ...
type B_SequenceD_listG_class (line 580) | struct B_SequenceD_listG_class
FILE: base/builtin/list.h
type B_list (line 2) | struct B_list {
type B_IteratorD_list (line 15) | struct B_IteratorD_list
type B_IteratorD_listG_class (line 17) | struct B_IteratorD_listG_class {
type B_IteratorD_list (line 30) | struct B_IteratorD_list {
type B_IteratorD_listG_class (line 36) | struct B_IteratorD_listG_class
FILE: base/builtin/none.c
function B_NoneType (line 15) | B_NoneType B_NoneTypeG_new() {
function B_NoneTypeD__serialize__ (line 20) | void B_NoneTypeD__serialize__(B_NoneType self, $Serial$state state) {
function B_NoneType (line 24) | B_NoneType B_NoneTypeD__deserialize__(B_NoneType self, $Serial$state sta...
function B_bool (line 30) | B_bool B_NoneTypeD__bool__(B_NoneType self) {
function B_str (line 34) | B_str B_NoneTypeD__str__(B_NoneType self) {
type B_NoneTypeG_class (line 38) | struct B_NoneTypeG_class
FILE: base/builtin/none.h
type B_NoneTypeG_class (line 1) | struct B_NoneTypeG_class {
type B_NoneType (line 13) | struct B_NoneType {
type B_NoneTypeG_class (line 17) | struct B_NoneTypeG_class
FILE: base/builtin/range.c
function B_range (line 15) | B_range B_rangeG_new(B_int start, B_int stop, B_int step) {
function B_NoneType (line 20) | B_NoneType B_rangeD___init__(B_range self, B_int start, B_int stop, B_in...
function rangeD_U__next__ (line 79) | int64_t rangeD_U__next__(B_range self) {
function B_int (line 85) | B_int B_rangeD___next__(B_range self) {
function B_bool (line 99) | B_bool B_rangeD___bool__(B_range self) {
function B_str (line 103) | B_str B_rangeD___repr__(B_range self) {
function B_str (line 107) | B_str B_rangeD___str__(B_range self) {
function B_rangeD___serialize__ (line 111) | void B_rangeD___serialize__(B_range self, $Serial$state state) {
function B_range (line 117) | B_range B_rangeD___deserialize__(B_range self, $Serial$state state) {
FILE: base/builtin/range.h
type B_range (line 2) | struct B_range {
FILE: base/builtin/registration.c
function $register_force (line 25) | void $register_force(int classid, $WORD meths) {
function $register (line 31) | void $register($WORD meths) {
function $register_builtin (line 43) | void $register_builtin() {
function B_bool (line 101) | B_bool issubtype(int sub_id, int ancestor_id) {
FILE: base/builtin/serialize.c
function $enqueue (line 19) | void $enqueue($Serial$state state, $ROW elem) {
function $enqueue2 (line 26) | void $enqueue2(struct $ROWLISTHEADER *header, $ROW elem) {
function B_HashableD_WORDD___serialize__ (line 36) | void B_HashableD_WORDD___serialize__(B_HashableD_WORD self, $Serial$stat...
function B_HashableD_WORD (line 39) | B_HashableD_WORD B_HashableD_WORDD___deserialize__(B_HashableD_WORD self...
function B_bool (line 44) | B_bool B_HashableD_WORD_eq(B_HashableD_WORD wit, $WORD a, $WORD b) {
function B_bool (line 48) | B_bool B_HashableD_WORD_ne(B_HashableD_WORD wit, $WORD a, $WORD b) {
function B_NoneType (line 52) | B_NoneType B_HashableD_WORD_hash(B_HashableD_WORD wit, $WORD a, B_hasher...
type B_HashableD_WORDG_class (line 57) | struct B_HashableD_WORDG_class
type B_HashableD_WORD (line 71) | struct B_HashableD_WORD
type B_HashableD_WORD (line 72) | struct B_HashableD_WORD
function $ROW (line 77) | $ROW $add_header(int class_id, int blob_size, $Serial$state state) {
function $step_serialize (line 87) | void $step_serialize($WORD self, $Serial$state state) {
function $WORD (line 112) | $WORD $step_deserialize($Serial$state state) {
function $val_serialize (line 131) | void $val_serialize(int class_id, $WORD val,$Serial$state state) {
function $WORD (line 136) | $WORD $val_deserialize($Serial$state state) {
function $write_serialized (line 146) | void $write_serialized($ROW row, char *file) {
function $ROW (line 186) | $ROW $serialize($Serializable s, $WORD (*globmap)($WORD)) {
function $ROW (line 197) | $ROW $glob_serialize($Serializable self, $WORD (*globmap)($WORD)) {
function $serialize_file (line 209) | void $serialize_file($Serializable s, char *file) {
function $Serializable (line 213) | $Serializable $deserialize($ROW row, $WORD (*globmap)($WORD)) {
function $Serializable (line 223) | $Serializable $glob_deserialize($Serializable self, $ROW row, $WORD (*gl...
function $ROW (line 233) | $ROW $read_serialized(char *file) {
function $Serializable (line 278) | $Serializable $deserialize_file(char *file) {
FILE: base/builtin/serialize.h
type $ROW (line 9) | struct $ROW
type $ROW (line 11) | struct $ROW {
type $ROWLISTHEADER (line 18) | struct $ROWLISTHEADER {
type $Serial$state (line 25) | struct $Serial$state {
type B_HashableD_WORD (line 64) | struct B_HashableD_WORD
type B_HashableD_WORDG_class (line 66) | struct B_HashableD_WORDG_class {
type B_HashableD_WORD (line 81) | struct B_HashableD_WORD {
type B_HashableD_WORDG_class (line 85) | struct B_HashableD_WORDG_class
type B_HashableD_WORD (line 87) | struct B_HashableD_WORD
FILE: base/builtin/set.c
function B_set_insert_clean (line 27) | static void B_set_insert_clean(B_setentry *table, long mask, $WORD *key,...
function B_set_table_resize (line 46) | static int B_set_table_resize(B_set so, int minsize) {
function B_setentry (line 91) | static B_setentry *B_set_lookkey(B_set set, B_Hashable hashwit, $WORD ke...
function B_set_contains_entry (line 120) | static int B_set_contains_entry(B_set set, B_Hashable hashwit, $WORD el...
function B_set_add_entry (line 124) | void B_set_add_entry(B_set set, B_Hashable hashwit, $WORD key, long hash) {
function B_set (line 181) | B_set B_set_copy(B_set set, B_Hashable hashwit) {
function B_set_discard_entry (line 189) | static int B_set_discard_entry(B_set set, B_Hashable hashwit, $WORD elem...
function B_set (line 202) | B_set B_setG_new(B_Hashable hashwit, B_Iterable wit, $WORD iterable) {
function B_NoneType (line 206) | B_NoneType B_setD___init__(B_set set, B_Hashable hashwit, B_Iterable wit...
function B_bool (line 232) | B_bool B_setD___bool__(B_set self) {
function B_str (line 236) | B_str B_setD___str__(B_set self) {
function B_str (line 248) | B_str B_setD___repr__(B_set self) {
function B_setD___serialize__ (line 252) | void B_setD___serialize__(B_set self, $Serial$state state) {
function B_set (line 272) | B_set B_setD___deserialize__ (B_set res, $Serial$state state) {
function $WORD (line 305) | static $WORD B_IteratorD_set_next_entry(B_IteratorD_set self) {
function B_Iterator (line 321) | static B_Iterator B_set_iter_entry(B_set set) {
function $WORD (line 331) | static $WORD B_IteratorD_set_next(B_IteratorD_set self) {
function B_IteratorD_set (line 339) | B_IteratorD_set B_IteratorD_setG_new(B_set s) {
function B_IteratorD_set_init (line 343) | void B_IteratorD_set_init(B_IteratorD_set self, B_set set) {
function B_bool (line 348) | B_bool B_IteratorD_set_bool(B_IteratorD_set self) {
function B_str (line 352) | B_str B_IteratorD_set_str(B_IteratorD_set self) {
function B_IteratorD_set_serialize (line 356) | void B_IteratorD_set_serialize(B_IteratorD_set self, $Serial$state state) {
function B_IteratorD_set (line 361) | B_IteratorD_set B_IteratorD_setD__deserialize(B_IteratorD_set res, $Seri...
type B_IteratorD_setG_class (line 369) | struct B_IteratorD_setG_class
function B_Iterator (line 373) | B_Iterator B_SetD_setD___iter__ (B_SetD_set wit, B_set set) {
function B_NoneType (line 377) | B_NoneType B_SetD_setD_add (B_SetD_set wit, B_set set, $WORD elem) {
function B_set (line 383) | B_set B_SetD_setD___fromiter__(B_SetD_set wit, B_Iterable wit2, $WORD it...
function B_int (line 402) | B_int B_SetD_setD___len__ (B_SetD_set wit, B_set set) {
function B_bool (line 406) | B_bool B_SetD_setD___contains__ (B_SetD_set wit, B_set set, $WORD val) {
function B_bool (line 411) | B_bool B_SetD_setD___containsnot__ (B_SetD_set wit, B_set set, $WORD v) {
function B_bool (line 415) | B_bool B_SetD_setD_isdisjoint (B_SetD_set wit, B_set set, B_set other) {
function B_NoneType (line 435) | B_NoneType B_SetD_setD_update (B_SetD_set wit, B_set set, B_Iterable oth...
function B_NoneType (line 456) | B_NoneType B_SetD_setD_discard (B_SetD_set wit, B_set set, $WORD elem) {
function $WORD (line 462) | $WORD B_SetD_setD_pop (B_SetD_set wit, B_set set) {
function B_bool (line 487) | B_bool B_OrdD_SetD_setD___eq__ (B_OrdD_SetD_set wit, B_set set, B_set ot...
function B_bool (line 504) | B_bool B_OrdD_SetD_setD___ne__ (B_OrdD_SetD_set wit, B_set set, B_set ot...
function B_bool (line 508) | B_bool B_OrdD_SetD_setD___gt__ (B_OrdD_SetD_set wit, B_set set, B_set ot...
function B_bool (line 525) | B_bool B_OrdD_SetD_setD___ge__ (B_OrdD_SetD_set wit, B_set set, B_set ot...
function B_bool (line 542) | B_bool B_OrdD_SetD_setD___lt__ (B_OrdD_SetD_set wit, B_set set, B_set ot...
function B_bool (line 546) | B_bool B_OrdD_SetD_setD___le__ (B_OrdD_SetD_set wit, B_set set, B_set ot...
function B_set (line 553) | B_set B_MinusD_SetD_setD___sub__ (B_MinusD_SetD_set wit, B_set set, B_se...
function B_set (line 571) | B_set B_LogicalD_SetD_setD___and__(B_LogicalD_SetD_set wit, B_set set, B...
function B_set (line 589) | B_set B_LogicalD_SetD_setD___or__ (B_LogicalD_SetD_set wit, B_set set, B...
function B_set (line 606) | B_set B_LogicalD_SetD_setD___xor__(B_LogicalD_SetD_set wit, B_set set, B...
FILE: base/builtin/set.h
type B_setentry (line 2) | typedef struct {
type B_set (line 7) | struct B_set {
type B_IteratorD_set (line 19) | struct B_IteratorD_set
type B_IteratorD_setG_class (line 21) | struct B_IteratorD_setG_class {
type B_IteratorD_set (line 34) | struct B_IteratorD_set {
type B_IteratorD_setG_class (line 40) | struct B_IteratorD_setG_class
FILE: base/builtin/slice.c
function normalize_slice (line 28) | void normalize_slice(B_slice slc, int64_t len, int64_t *slen, int64_t *s...
function B_slice (line 57) | B_slice B_sliceG_new(B_int start, B_int stop, B_int step) {
function B_NoneType (line 61) | B_NoneType B_sliceD___init__(B_slice s, B_int start, B_int stop, B_int s...
function B_sliceD___serialize__ (line 80) | void B_sliceD___serialize__ (B_slice self, $Serial$state state) {
function B_slice (line 86) | B_slice B_sliceD___deserialize__ (B_slice self, $Serial$state state) {
function B_bool (line 101) | B_bool B_sliceD___bool__(B_slice s) {
function B_str (line 105) | B_str B_sliceD___str__(B_slice s) {
function B_str (line 109) | B_str B_sliceD___repr__(B_slice s) {
FILE: base/builtin/slice.h
type B_slice (line 2) | struct B_slice {
FILE: base/builtin/staticWitnesses.c
type B_HashableD_bytes (line 1) | struct B_HashableD_bytes
type B_TimesD_bytes (line 2) | struct B_TimesD_bytes
type B_ContainerD_bytes (line 3) | struct B_ContainerD_bytes
type B_SliceableD_bytes (line 4) | struct B_SliceableD_bytes
type B_OrdD_bytes (line 5) | struct B_OrdD_bytes
type B_ContainerD_bytearray (line 6) | struct B_ContainerD_bytearray
type B_TimesD_SequenceD_bytearray (line 7) | struct B_TimesD_SequenceD_bytearray
type B_CollectionD_SequenceD_bytearray (line 8) | struct B_CollectionD_SequenceD_bytearray
type B_SequenceD_bytearray (line 9) | struct B_SequenceD_bytearray
type B_OrdD_bytearray (line 10) | struct B_OrdD_bytearray
type B_HashableD_str (line 11) | struct B_HashableD_str
type B_TimesD_str (line 12) | struct B_TimesD_str
type B_SliceableD_str (line 13) | struct B_SliceableD_str
type B_ContainerD_str (line 14) | struct B_ContainerD_str
type B_OrdD_str (line 15) | struct B_OrdD_str
type B_IterableD_Iterator (line 17) | struct B_IterableD_Iterator
type B_SetD_set (line 18) | struct B_SetD_set
type B_OrdD_dict (line 19) | struct B_OrdD_dict
type B_MappingD_dict (line 20) | struct B_MappingD_dict
type B_OrdD_list (line 21) | struct B_OrdD_list
type B_ContainerD_list (line 22) | struct B_ContainerD_list
type B_TimesD_SequenceD_list (line 23) | struct B_TimesD_SequenceD_list
type B_CollectionD_SequenceD_list (line 24) | struct B_CollectionD_SequenceD_list
type B_SequenceD_list (line 25) | struct B_SequenceD_list
type B_SequenceD_list (line 26) | struct B_SequenceD_list
type B_HashableD_complex (line 27) | struct B_HashableD_complex
type B_EqD_complex (line 28) | struct B_EqD_complex
type B_DivD_complex (line 29) | struct B_DivD_complex
type B_MinusD_NumberD_complex (line 30) | struct B_MinusD_NumberD_complex
type B_NumberD_complex (line 31) | struct B_NumberD_complex
type B_HashableD_float (line 32) | struct B_HashableD_float
type B_OrdD_float (line 33) | struct B_OrdD_float
type B_DivD_float (line 34) | struct B_DivD_float
type B_MinusD_RealFloatD_float (line 35) | struct B_MinusD_RealFloatD_float
type B_RealFloatD_float (line 36) | struct B_RealFloatD_float
type B_HashableD_u1 (line 37) | struct B_HashableD_u1
type B_OrdD_u1 (line 38) | struct B_OrdD_u1
type B_DivD_u1 (line 39) | struct B_DivD_u1
type B_LogicalD_IntegralD_u1 (line 40) | struct B_LogicalD_IntegralD_u1
type B_MinusD_IntegralD_u1 (line 41) | struct B_MinusD_IntegralD_u1
type B_IntegralD_u1 (line 42) | struct B_IntegralD_u1
type B_HashableD_u8 (line 43) | struct B_HashableD_u8
type B_OrdD_u8 (line 44) | struct B_OrdD_u8
type B_DivD_u8 (line 45) | struct B_DivD_u8
type B_LogicalD_IntegralD_u8 (line 46) | struct B_LogicalD_IntegralD_u8
type B_MinusD_IntegralD_u8 (line 47) | struct B_MinusD_IntegralD_u8
type B_IntegralD_u8 (line 48) | struct B_IntegralD_u8
type B_HashableD_u16 (line 49) | struct B_HashableD_u16
type B_OrdD_u16 (line 50) | struct B_OrdD_u16
type B_DivD_u16 (line 51) | struct B_DivD_u16
type B_LogicalD_IntegralD_u16 (line 52) | struct B_LogicalD_IntegralD_u16
type B_MinusD_IntegralD_u16 (line 53) | struct B_MinusD_IntegralD_u16
type B_IntegralD_u16 (line 54) | struct B_IntegralD_u16
type B_HashableD_u32 (line 55) | struct B_HashableD_u32
type B_OrdD_u32 (line 56) | struct B_OrdD_u32
type B_DivD_u32 (line 57) | struct B_DivD_u32
type B_LogicalD_IntegralD_u32 (line 58) | struct B_LogicalD_IntegralD_u32
type B_MinusD_IntegralD_u32 (line 59) | struct B_MinusD_IntegralD_u32
type B_IntegralD_u32 (line 60) | struct B_IntegralD_u32
type B_HashableD_u64 (line 61) | struct B_HashableD_u64
type B_OrdD_u64 (line 62) | struct B_OrdD_u64
type B_DivD_u64 (line 63) | struct B_DivD_u64
type B_LogicalD_IntegralD_u64 (line 64) | struct B_LogicalD_IntegralD_u64
type B_MinusD_IntegralD_u64 (line 65) | struct B_MinusD_IntegralD_u64
type B_IntegralD_u64 (line 66) | struct B_IntegralD_u64
type B_HashableD_i8 (line 67) | struct B_HashableD_i8
type B_OrdD_i8 (line 68) | struct B_OrdD_i8
type B_DivD_i8 (line 69) | struct B_DivD_i8
type B_LogicalD_IntegralD_i8 (line 70) | struct B_LogicalD_IntegralD_i8
type B_MinusD_IntegralD_i8 (line 71) | struct B_MinusD_IntegralD_i8
type B_IntegralD_i8 (line 72) | struct B_IntegralD_i8
type B_HashableD_i16 (line 73) | struct B_HashableD_i16
type B_OrdD_i16 (line 74) | struct B_OrdD_i16
type B_DivD_i16 (line 75) | struct B_DivD_i16
type B_LogicalD_IntegralD_i16 (line 76) | struct B_LogicalD_IntegralD_i16
type B_MinusD_IntegralD_i16 (line 77) | struct B_MinusD_IntegralD_i16
type B_IntegralD_i16 (line 78) | struct B_IntegralD_i16
type B_HashableD_i32 (line 79) | struct B_HashableD_i32
type B_OrdD_i32 (line 80) | struct B_OrdD_i32
type B_DivD_i32 (line 81) | struct B_DivD_i32
type B_LogicalD_IntegralD_i32 (line 82) | struct B_LogicalD_IntegralD_i32
type B_MinusD_IntegralD_i32 (line 83) | struct B_MinusD_IntegralD_i32
type B_IntegralD_i32 (line 84) | struct B_IntegralD_i32
type B_HashableD_int (line 85) | struct B_HashableD_int
type B_OrdD_int (line 86) | struct B_OrdD_int
type B_DivD_int (line 87) | struct B_DivD_int
type B_LogicalD_IntegralD_int (line 88) | struct B_LogicalD_IntegralD_int
type B_MinusD_IntegralD_int (line 89) | struct B_MinusD_IntegralD_int
type B_IntegralD_int (line 90) | struct B_IntegralD_int
type B_HashableD_bigint (line 91) | struct B_HashableD_bigint
type B_OrdD_bigint (line 92) | struct B_OrdD_bigint
type B_DivD_bigint (line 93) | struct B_DivD_bigint
type B_LogicalD_IntegralD_bigint (line 94) | struct B_LogicalD_IntegralD_bigint
type B_MinusD_IntegralD_bigint (line 95) | struct B_MinusD_IntegralD_bigint
type B_IntegralD_bigint (line 96) | struct B_IntegralD_bigint
type B_HashableD_bool (line 97) | struct B_HashableD_bool
type B_HashableD_bytes (line 98) | struct B_HashableD_bytes
type B_TimesD_bytes (line 99) | struct B_TimesD_bytes
type B_ContainerD_bytes (line 100) | struct B_ContainerD_bytes
type B_SliceableD_bytes (line 101) | struct B_SliceableD_bytes
type B_OrdD_bytes (line 102) | struct B_OrdD_bytes
type B_ContainerD_bytearray (line 103) | struct B_ContainerD_bytearray
type B_TimesD_SequenceD_bytearray (line 104) | struct B_TimesD_SequenceD_bytearray
type B_CollectionD_SequenceD_bytearray (line 105) | struct B_CollectionD_SequenceD_bytearray
type B_SequenceD_bytearray (line 106) | struct B_SequenceD_bytearray
type B_OrdD_bytearray (line 107) | struct B_OrdD_bytearray
type B_HashableD_str (line 108) | struct B_HashableD_str
type B_TimesD_str (line 109) | struct B_TimesD_str
type B_SliceableD_str (line 110) | struct B_SliceableD_str
type B_ContainerD_str (line 111) | struct B_ContainerD_str
type B_OrdD_str (line 112) | struct B_OrdD_str
type B_IterableD_Iterator (line 114) | struct B_IterableD_Iterator
type B_SetD_set (line 115) | struct B_SetD_set
type B_OrdD_dict (line 116) | struct B_OrdD_dict
type B_MappingD_dict (line 117) | struct B_MappingD_dict
type B_OrdD_list (line 118) | struct B_OrdD_list
type B_ContainerD_list (line 119) | struct B_ContainerD_list
type B_TimesD_SequenceD_list (line 120) | struct B_TimesD_SequenceD_list
type B_CollectionD_SequenceD_list (line 121) | struct B_CollectionD_SequenceD_list
type B_SequenceD_list (line 122) | struct B_SequenceD_list
type B_HashableD_complex (line 123) | struct B_HashableD_complex
type B_EqD_complex (line 124) | struct B_EqD_complex
type B_DivD_complex (line 125) | struct B_DivD_complex
type B_MinusD_NumberD_complex (line 127) | struct B_MinusD_NumberD_complex
type B_NumberD_complex (line 128) | struct B_NumberD_complex
type B_HashableD_float (line 129) | struct B_HashableD_float
type B_OrdD_float (line 130) | struct B_OrdD_float
type B_DivD_float (line 131) | struct B_DivD_float
type B_MinusD_RealFloatD_float (line 132) | struct B_MinusD_RealFloatD_float
type B_RealFloatD_float (line 133) | struct B_RealFloatD_float
type B_HashableD_u1 (line 134) | struct B_HashableD_u1
type B_OrdD_u1 (line 135) | struct B_OrdD_u1
type B_DivD_u1 (line 136) | struct B_DivD_u1
type B_LogicalD_IntegralD_u1 (line 137) | struct B_LogicalD_IntegralD_u1
type B_MinusD_IntegralD_u1 (line 138) | struct B_MinusD_IntegralD_u1
type B_IntegralD_u1 (line 139) | struct B_IntegralD_u1
type B_HashableD_u8 (line 141) | struct B_HashableD_u8
type B_OrdD_u8 (line 142) | struct B_OrdD_u8
type B_DivD_u8 (line 143) | struct B_DivD_u8
type B_LogicalD_IntegralD_u8 (line 144) | struct B_LogicalD_IntegralD_u8
type B_MinusD_IntegralD_u8 (line 145) | struct B_MinusD_IntegralD_u8
type B_IntegralD_u8 (line 146) | struct B_IntegralD_u8
type B_HashableD_u16 (line 147) | struct B_HashableD_u16
type B_OrdD_u16 (line 148) | struct B_OrdD_u16
type B_DivD_u16 (line 149) | struct B_DivD_u16
type B_LogicalD_IntegralD_u16 (line 150) | struct B_LogicalD_IntegralD_u16
type B_MinusD_IntegralD_u16 (line 151) | struct B_MinusD_IntegralD_u16
type B_IntegralD_u16 (line 152) | struct B_IntegralD_u16
type B_HashableD_u32 (line 153) | struct B_HashableD_u32
type B_OrdD_u32 (line 154) | struct B_OrdD_u32
type B_DivD_u32 (line 155) | struct B_DivD_u32
type B_LogicalD_IntegralD_u32 (line 156) | struct B_LogicalD_IntegralD_u32
type B_MinusD_IntegralD_u32 (line 157) | struct B_MinusD_IntegralD_u32
type B_IntegralD_u32 (line 158) | struct B_IntegralD_u32
type B_HashableD_u64 (line 159) | struct B_HashableD_u64
type B_OrdD_u64 (line 160) | struct B_OrdD_u64
type B_DivD_u64 (line 161) | struct B_DivD_u64
type B_LogicalD_IntegralD_u64 (line 162) | struct B_LogicalD_IntegralD_u64
type B_MinusD_IntegralD_u64 (line 163) | struct B_MinusD_IntegralD_u64
type B_IntegralD_u64 (line 164) | struct B_IntegralD_u64
type B_HashableD_i8 (line 165) | struct B_HashableD_i8
type B_OrdD_i8 (line 166) | struct B_OrdD_i8
type B_DivD_i8 (line 167) | struct B_DivD_i8
type B_LogicalD_IntegralD_i8 (line 168) | struct B_LogicalD_IntegralD_i8
type B_MinusD_IntegralD_i8 (line 169) | struct B_MinusD_IntegralD_i8
type B_IntegralD_i8 (line 170) | struct B_IntegralD_i8
type B_HashableD_i16 (line 171) | struct B_HashableD_i16
type B_OrdD_i16 (line 172) | struct B_OrdD_i16
type B_DivD_i16 (line 173) | struct B_DivD_i16
type B_LogicalD_IntegralD_i16 (line 174) | struct B_LogicalD_IntegralD_i16
type B_MinusD_IntegralD_i16 (line 175) | struct B_MinusD_IntegralD_i16
type B_IntegralD_i16 (line 176) | struct B_IntegralD_i16
type B_HashableD_i32 (line 177) | struct B_HashableD_i32
type B_OrdD_i32 (line 178) | struct B_OrdD_i32
type B_DivD_i32 (line 179) | struct B_DivD_i32
type B_LogicalD_IntegralD_i32 (line 180) | struct B_LogicalD_IntegralD_i32
type B_MinusD_IntegralD_i32 (line 181) | struct B_MinusD_IntegralD_i32
type B_IntegralD_i32 (line 182) | struct B_IntegralD_i32
type B_HashableD_int (line 183) | struct B_HashableD_int
type B_OrdD_int (line 184) | struct B_OrdD_int
type B_DivD_int (line 185) | struct B_DivD_int
type B_LogicalD_IntegralD_int (line 186) | struct B_LogicalD_IntegralD_int
type B_MinusD_IntegralD_int (line 187) | struct B_MinusD_IntegralD_int
type B_IntegralD_int (line 188) | struct B_IntegralD_int
type B_HashableD_bigint (line 189) | struct B_HashableD_bigint
type B_OrdD_bigint (line 190) | struct B_OrdD_bigint
type B_DivD_bigint (line 191) | struct B_DivD_bigint
type B_LogicalD_IntegralD_bigint (line 192) | struct B_LogicalD_IntegralD_bigint
type B_MinusD_IntegralD_bigint (line 193) | struct B_MinusD_IntegralD_bigint
type B_IntegralD_bigint (line 194) | struct B_IntegralD_bigint
type B_HashableD_bool (line 195) | struct B_HashableD_bool
type B_OrdD_list (line 299) | struct B_OrdD_list
type B_IndexedD_MappingD_dict (line 302) | struct B_IndexedD_MappingD_dict
type B_IndexedD_MappingD_dict (line 303) | struct B_IndexedD_MappingD_dict
type B_MappingD_dict (line 304) | struct B_MappingD_dict
type B_MappingD_dict (line 306) | struct B_MappingD_dict
type B_IndexedD_MappingD_dict (line 309) | struct B_IndexedD_MappingD_dict
type B_IndexedD_MappingD_dict (line 311) | struct B_IndexedD_MappingD_dict
FILE: base/builtin/str.c
type B_str (line 32) | struct B_str
type B_str (line 167) | struct B_str
type B_str (line 298) | struct B_str
type B_bytes (line 302) | struct B_bytes
type B_bytes (line 306) | struct B_bytes
type B_bytes (line 310) | struct B_bytes
type B_bytearray (line 316) | struct B_bytearray
type B_bytearray (line 320) | struct B_bytearray
function B_str (line 350) | B_str to$str(char *str) {
function B_str (line 393) | B_str to_str_noc(char *str) {
function byte_length (line 433) | static int byte_length(unsigned int cp) {
function byte_length2 (line 445) | static int byte_length2(unsigned char c) {
function B_str (line 461) | static B_str str_transform(B_str s, transform f) {
function char_no (line 485) | static int char_no(B_str text,int i) {
function byte_no (line 517) | static int byte_no(B_str text, int i) {
function get_index (line 529) | static int get_index(int i, int nchars) {
function fix_start_end (line 545) | static int fix_start_end(int nchars, B_int *start, B_int *end) {
function B_str (line 576) | static B_str mk_char(unsigned char *p) {
function equal_bytes (line 588) | int equal_bytes(unsigned char *p, unsigned char *q, int len) {
function isspace_codepoint (line 596) | static int isspace_codepoint(int codepoint) {
function islinebreak_codepoint (line 602) | static int islinebreak_codepoint(int codepoint) {
function bmh (line 617) | int bmh( unsigned char *text, unsigned char *pattern, int tbytes, int pb...
function rbmh (line 638) | static int rbmh( unsigned char *text, unsigned char *pattern, int tbytes...
type byte_counts (line 658) | struct byte_counts {
function byte_count (line 663) | struct byte_counts byte_count(unsigned char *s, int len) {
function escape_str (line 686) | void escape_str(unsigned char *out, unsigned char *in, int outlen, int i...
function B_str (line 763) | B_str B_strG_new(B_value s) {
function B_NoneType (line 767) | B_NoneType B_strD___init__(B_str self, B_value s) {
function B_bool (line 782) | B_bool B_strD___bool__(B_str s) {
function B_str (line 786) | B_str B_strD___str__(B_str s) {
function B_str (line 791) | B_str B_strD___repr__(B_str s) {
function B_strD___serialize__ (line 846) | void B_strD___serialize__(B_str str,$Serial$state state) {
function B_str (line 856) | B_str B_strD___deserialize__(B_str self, $Serial$state state) {
function B_str (line 876) | B_str B_strD_capitalize(B_str s) {
function B_str (line 898) | B_str B_strD_center(B_str s, B_int width, B_str fill) {
function B_int (line 931) | B_int B_strD_count(B_str s, B_str sub, B_int start, B_int end) {
function B_bytes (line 948) | B_bytes B_strD_encode(B_str s) {
function B_bool (line 955) | B_bool B_strD_endswith(B_str s, B_str sub, B_int start, B_int end) {
function B_str (line 971) | B_str B_strD_expandtabs(B_str s, B_int tabsize){
function B_int (line 1007) | B_int B_strD_find(B_str s, B_str sub, B_int start, B_int end) {
function B_int (line 1019) | B_int B_strD_index(B_str s, B_str sub, B_int start, B_int end) {
function B_bool (line 1027) | B_bool B_strD_isalnum(B_str s) {
function B_bool (line 1043) | B_bool B_strD_isalpha(B_str s) {
function B_bool (line 1059) | B_bool B_strD_isascii(B_str s) {
function B_bool (line 1069) | B_bool B_strD_isdecimal(B_str s) {
function B_bool (line 1085) | B_bool B_strD_islower(B_str s) {
function B_bool (line 1104) | B_bool B_strD_isprintable(B_str s) {
function B_bool (line 1120) | B_bool B_strD_isspace(B_str s) {
function B_bool (line 1135) | B_bool B_strD_istitle(B_str s) {
function B_bool (line 1162) | B_bool B_strD_isupper(B_str s) {
function B_str (line 1181) | B_str B_strD_join(B_str s, B_Iterable wit, $WORD iter) {
function B_str (line 1215) | B_str B_strD_ljust(B_str s, B_int width, B_str fill) {
function B_str (line 1237) | B_str B_strD_lower(B_str s) {
function B_str (line 1242) | B_str B_strD_lstrip(B_str s, B_str cs) {
function B_tuple (line 1264) | B_tuple B_strD_partition(B_str s, B_str sep) {
function B_str (line 1282) | B_str B_strD_replace(B_str s, B_str old, B_str new, B_int count) {
function B_int (line 1317) | B_int B_strD_rfind(B_str s, B_str sub, B_int start, B_int end) {
function B_int (line 1330) | B_int B_strD_rindex(B_str s, B_str sub, B_int start, B_int end) {
function B_str (line 1338) | B_str B_strD_rjust(B_str s, B_int width, B_str fill) {
function B_tuple (line 1360) | B_tuple B_strD_rpartition(B_str s, B_str sep) {
function B_list (line 1379) | B_list B_strD_split(B_str s, B_str sep, B_int maxsplit) {
function B_list (line 1457) | B_list B_strD_splitlines(B_str s, B_bool keepends) {
function B_str (line 1497) | B_str B_strD_rstrip(B_str s, B_str cs) {
function B_bool (line 1520) | B_bool B_strD_startswith(B_str s, B_str sub, B_int start, B_int end) {
function B_str (line 1536) | B_str B_strD_strip(B_str s, B_str cs) {
function B_str (line 1540) | B_str B_strD_upper(B_str s) {
function B_str (line 1544) | B_str B_strD_zfill(B_str s, B_int width) {
function B_bool (line 1581) | B_bool B_OrdD_strD___eq__ (B_OrdD_str wit, B_str a, B_str b) {
function B_bool (line 1585) | B_bool B_OrdD_strD___ne__ (B_OrdD_str wit, B_str a, B_str b) {
function B_bool (line 1589) | B_bool B_OrdD_strD___lt__ (B_OrdD_str wit, B_str a, B_str b) {
function B_bool (line 1593) | B_bool B_OrdD_strD___le__ (B_OrdD_str wit, B_str a, B_str b) {
function B_bool (line 1597) | B_bool B_OrdD_strD___gt__ (B_OrdD_str wit, B_str a, B_str b) {
function B_bool (line 1601) | B_bool B_OrdD_strD___ge__ (B_OrdD_str wit, B_str a, B_str b) {
function B_bool (line 1607) | B_bool B_HashableD_strD___eq__ (B_HashableD_str wit, B_str a, B_str b) {
function B_bool (line 1611) | B_bool B_HashableD_strD___ne__ (B_HashableD_str wit, B_str a, B_str b) {
function B_NoneType (line 1615) | B_NoneType B_HashableD_strD_hash(B_HashableD_str wit, B_str a, B_hasher ...
function B_str (line 1621) | B_str B_TimesD_strD___add__ (B_TimesD_str wit, B_str s, B_str t) {
function B_str (line 1629) | B_str B_TimesD_strD___zero__ (B_TimesD_str wit) {
function B_str (line 1633) | B_str B_TimesD_strD___mul__ (B_TimesD_str wit, B_str a, B_int n) {
function B_str (line 1649) | B_str B_ContainerD_strD___fromiter__ (B_ContainerD_str wit, B_Iterable w...
function B_int (line 1653) | B_int B_ContainerD_strD___len__ (B_ContainerD_str wit, B_str s){
function B_bool (line 1660) | B_bool B_ContainerD_strD___contains__ (B_ContainerD_str wit, B_str s, B_...
function B_bool (line 1664) | B_bool B_ContainerD_strD___containsnot__ (B_ContainerD_str wit, B_str s,...
function B_IteratorB_str (line 1672) | B_IteratorB_str B_IteratorB_strG_new(B_str str) {
function B_NoneType (line 1676) | B_NoneType B_IteratorB_strD_init(B_IteratorB_str self, B_str str) {
function B_IteratorB_strD_serialize (line 1682) | void B_IteratorB_strD_serialize(B_IteratorB_str self,$Serial$state state) {
function B_IteratorB_str (line 1688) | B_IteratorB_str B_IteratorB_str$_deserialize(B_IteratorB_str res, $Seria...
function B_bool (line 1696) | B_bool B_IteratorB_strD_bool(B_IteratorB_str self) {
function B_str (line 1700) | B_str B_IteratorB_strD_str(B_IteratorB_str self) {
function B_str (line 1705) | static B_str B_IteratorB_strD_next(B_IteratorB_str self) {
type B_IteratorB_strG_class (line 1716) | struct B_IteratorB_strG_class
function B_Iterator (line 1722) | B_Iterator B_ContainerD_strD___iter__ (B_ContainerD_str wit, B_str s) {
function B_str (line 1729) | B_str B_SliceableD_strD___getitem__ (B_SliceableD_str wit, B_str s, B_in...
function B_NoneType (line 1736) | B_NoneType B_SliceableD_strD___setitem__ (B_SliceableD_str wit, B_str st...
function B_NoneType (line 1741) | B_NoneType B_SliceableD_strD___delitem__ (B_SliceableD_str wit, B_str st...
function B_str (line 1748) | B_str B_SliceableD_strD___getslice__ (B_SliceableD_str wit, B_str s, B_s...
function B_NoneType (line 1779) | B_NoneType B_SliceableD_strD___setslice__ (B_SliceableD_str wit, B_str s...
function B_NoneType (line 1784) | B_NoneType B_SliceableD_strD___delslice__ (B_SliceableD_str wit, B_str s...
function B_bytearray (line 1795) | B_bytearray toB_bytearray(char *str) {
function B_bytearray (line 1804) | B_bytearray to$bytearrayD_len(char *str, int len) {
function B_bytearray (line 1811) | B_bytearray actBytearrayFromCString(char *str) {
function B_bytearray (line 1819) | B_bytearray actBytearrayFromCStringNoCopy(char *str) {
function B_bytearray (line 1827) | B_bytearray actBytearrayFromCStringLength(char *str, int len) {
function B_bytearray (line 1834) | B_bytearray actBytearrayFromCStringLengthNoCopy(char *str, int length) {
function expand_bytearray (line 1848) | static void expand_bytearray(B_bytearray b,int n) {
function B_bytearray (line 1864) | static B_bytearray B_bytearrayD_copy(B_bytearray s) {
function B_bytearray (line 1875) | B_bytearray B_bytearrayG_new(B_bytes b) {
function B_NoneType (line 1879) | B_NoneType B_bytearrayD___init__(B_bytearray self, B_bytes b) {
function B_bool (line 1888) | B_bool B_bytearrayD___bool__(B_bytearray s) {
function B_str (line 1892) | B_str B_bytearrayD___str__(B_bytearray s) {
function B_str (line 1913) | B_str B_bytearrayD___repr__(B_bytearray s) {
function B_bytearrayD___serialize__ (line 1917) | void B_bytearrayD___serialize__(B_bytearray str,$Serial$state state) {
function B_bytearray (line 1925) | B_bytearray B_bytearrayD___deserialize__(B_bytearray res, $Serial$state ...
function B_bytearray (line 1942) | B_bytearray B_bytearrayD_capitalize(B_bytearray s) {
function B_bytearray (line 1954) | B_bytearray B_bytearrayD_center(B_bytearray s, B_int width, B_bytearray ...
function B_int (line 1981) | B_int B_bytearrayD_count(B_bytearray s, B_bytearray sub, B_int start, B_...
function B_str (line 1999) | B_str B_bytearrayD_decode(B_bytearray s) {
function B_bool (line 2003) | B_bool B_bytearrayD_endswith(B_bytearray s, B_bytearray sub, B_int start...
function B_bytearray (line 2018) | B_bytearray B_bytearrayD_expandtabs(B_bytearray s, B_int tabsz){
function B_int (line 2054) | B_int B_bytearrayD_find(B_bytearray s, B_bytearray sub, B_int start, B_i...
function B_bytearray (line 2065) | B_bytearray B_bytearrayD_from_hex(B_str s) {
function B_str (line 2111) | B_str B_bytearrayD_hex(B_bytearray s) {
function B_int (line 2131) | B_int B_bytearrayD_index(B_bytearray s, B_bytearray sub, B_int start, B_...
function B_bool (line 2139) | B_bool B_bytearrayD_isalnum(B_bytearray s) {
function B_bool (line 2150) | B_bool B_bytearrayD_isalpha(B_bytearray s) {
function B_bool (line 2161) | B_bool B_bytearrayD_isascii(B_bytearray s) {
function B_bool (line 2170) | B_bool B_bytearrayD_isdigit(B_bytearray s) {
function B_bool (line 2182) | B_bool B_bytearrayD_islower(B_bytearray s) {
function B_bool (line 2194) | B_bool B_bytearrayD_isspace(B_bytearray s) {
function B_bool (line 2205) | B_bool B_bytearrayD_istitle(B_bytearray s) {
function B_bool (line 2224) | B_bool B_bytearrayD_isupper(B_bytearray s) {
function B_bytearray (line 2236) | B_bytearray B_bytearrayD_join(B_bytearray s, B_Iterable wit, $WORD iter) {
function B_bytearray (line 2267) | B_bytearray B_bytearrayD_ljust(B_bytearray s, B_int width, B_bytearray f...
function B_bytearray (line 2287) | B_bytearray B_bytearrayD_lower(B_bytearray s) {
function B_bytearray (line 2295) | B_bytearray B_bytearrayD_lstrip(B_bytearray s, B_bytearray cs) {
function B_tuple (line 2318) | B_tuple B_bytearrayD_partition(B_bytearray s, B_bytearray sep) {
function B_bytearray (line 2336) | B_bytearray B_bytearrayD_replace(B_bytearray s, B_bytearray old, B_bytea...
function B_int (line 2370) | B_int B_bytearrayD_rfind(B_bytearray s, B_bytearray sub, B_int start, B_...
function B_int (line 2382) | B_int B_bytearrayD_rindex(B_bytearray s, B_bytearray sub, B_int start, B...
function B_bytearray (line 2390) | B_bytearray B_bytearrayD_rjust(B_bytearray s, B_int width, B_bytearray f...
function B_tuple (line 2411) | B_tuple B_bytearrayD_rpartition(B_bytearray s, B_bytearray sep) {
function B_bytearray (line 2428) | B_bytearray B_bytearrayD_rstrip(B_bytearray s, B_bytearray cs) {
function B_list (line 2450) | B_list B_bytearrayD_split(B_bytearray s, B_bytearray sep, B_int maxsplit) {
function B_list (line 2519) | B_list B_bytearrayD_splitlines(B_bytearray s, B_bool keepends) {
function B_bool (line 2553) | B_bool B_bytearrayD_startswith(B_bytearray s, B_bytearray sub, B_int sta...
function B_bytearray (line 2569) | B_bytearray B_bytearrayD_strip(B_bytearray s, B_bytearray cs) {
function B_bytearray (line 2573) | B_bytearray B_bytearrayD_upper(B_bytearray s) {
function B_bytearray (line 2581) | B_bytearray B_bytearrayD_zfill(B_bytearray s, B_int width) {
function B_bool (line 2605) | B_bool B_OrdD_bytearrayD___eq__ (B_OrdD_bytearray wit, B_bytearray a, B_...
function B_bool (line 2609) | B_bool B_OrdD_bytearrayD___ne__ (B_OrdD_bytearray wit, B_bytearray a, B_...
function B_bool (line 2613) | B_bool B_OrdD_bytearrayD___lt__ (B_OrdD_bytearray wit, B_bytearray a, B_...
function B_bool (line 2617) | B_bool B_OrdD_bytearrayD___le__ (B_OrdD_bytearray wit, B_bytearray a, B_...
function B_bool (line 2621) | B_bool B_OrdD_bytearrayD___gt__ (B_OrdD_bytearray wit, B_bytearray a, B_...
function B_bool (line 2625) | B_bool B_OrdD_bytearrayD___ge__ (B_OrdD_bytearray wit, B_bytearray a, B_...
function B_int (line 2633) | static B_int B_IteratorB_bytearrayD_next(B_IteratorB_bytearray self) {
function B_NoneType (line 2639) | B_NoneType B_IteratorB_bytearrayD_init(B_IteratorB_bytearray self, B_byt...
function B_bool (line 2645) | B_bool B_IteratorB_bytearrayD_bool(B_IteratorB_bytearray self) {
function B_str (line 2649) | B_str B_IteratorB_bytearrayD_str(B_IteratorB_bytearray self) {
function B_IteratorB_bytearrayD_serialize (line 2653) | void B_IteratorB_bytearrayD_serialize(B_IteratorB_bytearray self,$Serial...
function B_IteratorB_bytearray (line 2658) | B_IteratorB_bytearray B_IteratorB_bytearray$_deserialize(B_IteratorB_byt...
type B_IteratorB_bytearrayG_class (line 2666) | struct B_IteratorB_bytearrayG_class
function B_Iterator (line 2679) | B_Iterator B_ContainerD_bytearrayD___iter__ (B_ContainerD_bytearray wit,...
function B_bytearray (line 2683) | B_bytearray B_ContainerD_bytearrayD___fromiter__ (B_ContainerD_bytearray...
function B_int (line 2687) | B_int B_ContainerD_bytearrayD___len__ (B_ContainerD_bytearray wit, B_byt...
function B_bool (line 2691) | B_bool B_ContainerD_bytearrayD___contains__(B_ContainerD_bytearray wit, ...
function B_bool (line 2702) | B_bool B_ContainerD_bytearrayD___containsnot__(B_ContainerD_bytearray wi...
function B_int (line 2708) | B_int B_SequenceD_bytearrayD___getitem__ (B_SequenceD_bytearray wit, B_b...
function B_NoneType (line 2716) | B_NoneType B_SequenceD_bytearrayD___setitem__ (B_SequenceD_bytearray wit...
function B_NoneType (line 2728) | B_NoneType B_SequenceD_bytearrayD___delitem__ (B_SequenceD_bytearray wit...
function B_NoneType (line 2739) | B_NoneType B_SequenceD_bytearrayD_insert(B_SequenceD_bytearray wit, B_by...
function B_NoneType (line 2752) | B_NoneType B_SequenceD_bytearrayD_append(B_SequenceD_bytearray wit, B_by...
function B_NoneType (line 2759) | B_NoneType B_SequenceD_bytearrayD_reverse(B_SequenceD_bytearray wit, B_b...
function B_Iterator (line 2769) | B_Iterator B_SequenceD_bytearrayD___reversed__(B_SequenceD_bytearray wit...
function B_bytearray (line 2775) | B_bytearray B_SequenceD_bytearrayD___getslice__ (B_SequenceD_bytearray w...
function B_NoneType (line 2790) | B_NoneType B_SequenceD_bytearrayD___setslice__ (B_SequenceD_bytearray wi...
function B_NoneType (line 2833) | B_NoneType B_SequenceD_bytearrayD___delslice__ (B_SequenceD_bytearray wi...
function B_Iterator (line 2852) | B_Iterator B_CollectionD_SequenceD_bytearrayD___iter__ (B_CollectionD_Se...
function B_bytearray (line 2856) | B_bytearray B_CollectionD_SequenceD_bytearrayD___fromiter__ (B_Collectio...
function B_int (line 2860) | B_int B_CollectionD_SequenceD_bytearrayD___len__ (B_CollectionD_Sequence...
function B_bytearray (line 2866) | B_bytearray B_TimesD_SequenceD_bytearrayD___add__ (B_TimesD_SequenceD_by...
function B_bytearray (line 2874) | B_bytearray B_TimesD_SequenceD_bytearrayD___zero__ (B_TimesD_SequenceD_b...
function B_bytearray (line 2878) | B_bytearray B_TimesD_SequenceD_bytearrayD___mul__ (B_TimesD_SequenceD_by...
function B_bytes (line 2900) | B_bytes to$bytes(char *str) {
function B_bytes (line 2908) | B_bytes to$bytesD_len(char *str, int len) {
function B_bytes (line 2915) | B_bytes actBytesFromCString(char *str) {
function B_bytes (line 2923) | B_bytes actBytesFromCStringNoCopy(char *str
Copy disabled (too large)
Download .json
Condensed preview — 1091 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (10,049K chars).
[
{
"path": ".containerignore",
"chars": 8,
"preview": "*\n!dist\n"
},
{
"path": ".github/ISSUE_TEMPLATE/blank_issue.md",
"chars": 55,
"preview": "---\nname: Blank Issue\nabout: Create a blank issue.\n---\n"
},
{
"path": ".github/ISSUE_TEMPLATE/bug.yaml",
"chars": 1112,
"preview": "name: \"\\U0001F41E Bug Report\"\ndescription: \"Create a bug report for Acton.\"\nlabels: [\"bug\"]\nbody:\n - type: markdown\n "
},
{
"path": ".github/ISSUE_TEMPLATE/config.yml",
"chars": 215,
"preview": "blank_issues_enabled: true\ncontact_links:\n - name: 🗣 Ask a Question, Discuss\n url: https://github.com/actonlang/acto"
},
{
"path": ".github/ISSUE_TEMPLATE/feature.yaml",
"chars": 1125,
"preview": "name: \"\\U0001F680 Feature / Enhancement Request\"\ndescription: \"Suggest a new idea / feature enhancement for Acton.\"\nlabe"
},
{
"path": ".github/ISSUE_TEMPLATE/ice.yaml",
"chars": 1677,
"preview": "name: \"\\U0001F4A5 Internal Compiler Error\"\ndescription: \"Create a report for an Internal Compiler Error (ICE) in acton.\""
},
{
"path": ".github/dependabot.yml",
"chars": 255,
"preview": "# https://docs.github.com/github/administering-a-repository/configuration-options-for-dependency-updates\nversion: 2\nupda"
},
{
"path": ".github/workflows/claude.yml",
"chars": 1102,
"preview": "name: Claude Code\n\non:\n issue_comment:\n types: [created]\n pull_request_review_comment:\n types: [created]\n issue"
},
{
"path": ".github/workflows/code-agent.yml",
"chars": 1271,
"preview": "name: Code Agent\n\npermissions:\n contents: write\n pull-requests: write\n issues: write\n\non:\n issues:\n types: [opene"
},
{
"path": ".github/workflows/create-release.yml",
"chars": 3316,
"preview": "name: Create Release Branch\n\non:\n workflow_dispatch:\n inputs:\n release_type:\n description: 'Release Type"
},
{
"path": ".github/workflows/release.yml",
"chars": 886,
"preview": "name: Add git tag for release\n\non:\n pull_request:\n types:\n - closed\n\njobs:\n if_merged:\n # name should be e."
},
{
"path": ".github/workflows/test-app.yml",
"chars": 929,
"preview": "\non:\n workflow_call:\n inputs:\n repo_url:\n required: true\n type: string\n arch:\n requir"
},
{
"path": ".github/workflows/test.yml",
"chars": 38948,
"preview": "name: Build, Test & Release\n\n# Build, Test & Release (BTR) run for:\n# - pushes to the main branch\n# - new tags are pushe"
},
{
"path": ".github/workflows/trigger-web-update.yml",
"chars": 794,
"preview": "name: Trigger rebuild of Acton Web page\n\n# When there are changes to files under docs/acton-guide on main branch,\n# trig"
},
{
"path": ".github/workflows/update-ask-acton-vector-store.yml",
"chars": 1343,
"preview": "name: Update Ask Acton vector store\n\non:\n push:\n branches:\n - main\n paths:\n - 'docs/acton-guide/**'\n w"
},
{
"path": ".github/workflows/webex-notifications.yml",
"chars": 2215,
"preview": "name: Webex Notifications\n\non:\n pull_request:\n types: [closed]\n branches: [main]\n\njobs:\n notify-webex:\n runs-"
},
{
"path": ".gitignore",
"chars": 1320,
"preview": "**/.ccls-cache/*\n**/.zig-cache/*\n\n*~\n*.o\n*.a\n**/.DS_Store\n**/.stack-work\n**/*.dSYM\n**/*.hi\n**/*.o\n**/a.out\n**/build.zig*"
},
{
"path": ".gitmodules",
"chars": 95,
"preview": "[submodule \"test/Unity\"]\n\tpath = test/Unity\n\turl = https://github.com/ThrowTheSwitch/Unity.git\n"
},
{
"path": "AGENTS.md",
"chars": 400,
"preview": "Acton compiler notes:\n\n- `acton build --no-threads` controls whether the produced Acton binary uses\n threads in Acton R"
},
{
"path": "CHANGELOG.md",
"chars": 216413,
"preview": "# Changelog\n\n## Unreleased\n\n### Compiler & Build\n- Add concurrent top-level type checking for total statements, allowing"
},
{
"path": "CLAUDE.md",
"chars": 6681,
"preview": "# Acton Programming Language - Development Guide\n\nActon is an actor-based programming language with distributed computin"
},
{
"path": "CONTRIBUTING.md",
"chars": 996,
"preview": "# Contributing to Acton\n\nHi and thanks for your interest in contributing to Acton! It is possible to\ncontribute in many "
},
{
"path": "Containerfile",
"chars": 295,
"preview": "FROM debian:13\nMAINTAINER Kristian Larsson <kristian@spritelink.net>\n\nCOPY dist/ /usr/lib/acton/\n\nRUN cd /usr/bin \\\n && "
},
{
"path": "Containerfile.deb",
"chars": 327,
"preview": "FROM debian:13\nMAINTAINER Kristian Larsson <kristian@spritelink.net>\n\nARG TARGETARCH\nCOPY deb/acton_*${TARGETARCH}.deb /"
},
{
"path": "LICENSE",
"chars": 1512,
"preview": "Copyright (C) 2019-2021 Data Ductus AB\nCopyright (C) 2019-2021 Deutsche Telekom AG\n\nRedistribution and use in source and"
},
{
"path": "Makefile",
"chars": 20844,
"preview": "include version.mk\nTD := $(CURDIR)\nCHANGELOG_VERSION=$(shell grep '^\\#\\# \\[[0-9]' CHANGELOG.md | sed 's/\\#\\# \\[\\([^]]\\{1"
},
{
"path": "README.md",
"chars": 3476,
"preview": "# The Acton programming language\n[](http"
},
{
"path": "backend/.gitignore",
"chars": 0,
"preview": ""
},
{
"path": "backend/Build.act",
"chars": 50,
"preview": "name = \"actondb\"\nfingerprint = 0xb1be0c7ca3b92d45\n"
},
{
"path": "backend/CLAUDE.md",
"chars": 7244,
"preview": "# Acton Backend - Distributed Runtime & Database\n\nThe backend provides distributed computing capabilities, actor persist"
},
{
"path": "backend/actondb.c",
"chars": 111493,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/client_api.c",
"chars": 128143,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/client_api.h",
"chars": 17531,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/comm.c",
"chars": 21067,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/comm.h",
"chars": 1828,
"preview": "/*\n * comm.h\n *\n * Author: aagapi\n */\n\n#ifndef BACKEND_COMM_H_\n#define BACKEND_COMM_H_\n\n#include \"failure_detector/"
},
{
"path": "backend/common.h",
"chars": 1980,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/consumer_state.h",
"chars": 2384,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/db.c",
"chars": 40924,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/db.h",
"chars": 11735,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/db_client_api.h",
"chars": 162,
"preview": "/*\n * db_client_api.h\n *\n * Author: aagapi\n */\n\n#ifndef BACKEND_DB_CLIENT_API_H_\n#define BACKEND_DB_CLIENT_API_H_\n\n"
},
{
"path": "backend/failure_detector/cells.c",
"chars": 12922,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/failure_detector/cells.h",
"chars": 2814,
"preview": "/*\n * cells.h\n *\n * Author: aagapi\n */\n\n#ifndef BACKEND_FAILURE_DETECTOR_CELLS_H_\n#define BACKEND_FAILURE_DETECTOR_"
},
{
"path": "backend/failure_detector/db_messages.pb-c.c",
"chars": 114351,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/failure_detector/db_messages.pb-c.h",
"chars": 45870,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/failure_detector/db_messages.proto",
"chars": 8013,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/failure_detector/db_messages_test.c",
"chars": 17966,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/failure_detector/db_queries.c",
"chars": 78300,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/failure_detector/db_queries.h",
"chars": 15105,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/failure_detector/fd.c",
"chars": 18171,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/failure_detector/fd.h",
"chars": 4263,
"preview": "/*\n * fd.h\n *\n * Author: aagapi\n */\n\n#ifndef BACKEND_FAILURE_DETECTOR_FD_H_\n#define BACKEND_FAILURE_DETECTOR_FD_H_\n\n#inc"
},
{
"path": "backend/failure_detector/txns.h",
"chars": 237,
"preview": "/*\n * txns.h\n * Author: aagapi\n */\n\n#ifndef BACKEND_FAILURE_DETECTOR_TXNS_H_\n#define BACKEND_FAILURE_DETECTOR_TXNS_"
},
{
"path": "backend/failure_detector/vector_clock.c",
"chars": 10614,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/failure_detector/vector_clock.h",
"chars": 3731,
"preview": "/*\n * vector_clock.h\n *\n * Author: aagapi\n */\n\n#ifndef BACKEND_FAILURE_DETECTOR_VECTOR_CLOCK_H_\n#define BACKEND_FAILURE_"
},
{
"path": "backend/fastrand.h",
"chars": 1534,
"preview": "\n#include <time.h>\n\n#ifndef FASTRAND_H_\n#define FASTRAND_H_\n\n#if( defined _POSIX_THREADS && _POSIX_TIMERS >= 0 && _POSIX"
},
{
"path": "backend/hash_ring.c",
"chars": 6049,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/hash_ring.h",
"chars": 2887,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/hashes.h",
"chars": 1817,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/log.c",
"chars": 4035,
"preview": "/*\n * Copyright (c) 2020 rxi\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of th"
},
{
"path": "backend/log.h",
"chars": 1432,
"preview": "/**\n * Copyright (c) 2020 rxi\n *\n * This library is free software; you can redistribute it and/or modify it\n * under the"
},
{
"path": "backend/queue.c",
"chars": 44277,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/queue.h",
"chars": 6240,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/queue_callback.c",
"chars": 3209,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/queue_callback.h",
"chars": 2451,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/queue_groups.c",
"chars": 6721,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/queue_groups.h",
"chars": 3079,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/skiplist.c",
"chars": 8260,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/skiplist.h",
"chars": 1357,
"preview": "/*\n * skiplist.h\n *\n */\n\n#ifndef BACKEND_SKIPLIST_H_\n#define BACKEND_SKIPLIST_H_\n\ntypedef void *WORD;\n\n#define SKIPLIST_"
},
{
"path": "backend/test/actor_ring_tests_local.c",
"chars": 23597,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/test/actor_ring_tests_remote.c",
"chars": 23324,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/test/db_unit_tests.c",
"chars": 15485,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/test/queue_unit_tests.c",
"chars": 14083,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/test/skiplist_test.c",
"chars": 3006,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/test/test_client.c",
"chars": 15121,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/txn_state.c",
"chars": 26488,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/txn_state.h",
"chars": 6028,
"preview": "/*\n * txn_state.h\n */\n\n#ifndef BACKEND_TXN_STATE_H_\n#define BACKEND_TXN_STATE_H_\n\n#include <uuid/uuid.h>\n#include \"db.h\""
},
{
"path": "backend/txns.c",
"chars": 31757,
"preview": "/*\n * Copyright (C) 2019-2021 Deutsche Telekom AG\n *\n * Redistribution and use in source and binary forms, with or witho"
},
{
"path": "backend/txns.h",
"chars": 4794,
"preview": "/*\n * txns.h\n *\n * Author: aagapi\n */\n\n#ifndef BACKEND_TXNS_H_\n#define BACKEND_TXNS_H_\n\n#include \"txn_state.h\"\n#inc"
},
{
"path": "base/.gitignore",
"chars": 0,
"preview": ""
},
{
"path": "base/Build.act",
"chars": 903,
"preview": "name = \"base\"\nfingerprint = 0xc0b4fe61c0b4fe61\n\ndependencies = {\n \"actondb\": (\n path=\"../backend/\"\n )\n}\n\nzi"
},
{
"path": "base/CLAUDE.md",
"chars": 6654,
"preview": "# Acton Base - Standard Library & Runtime System\n\nThe base directory contains the Acton standard library and runtime sys"
},
{
"path": "base/__root.zig",
"chars": 3580,
"preview": "const std = @import(\"std\");\n\nconst acton = @import(\"acton.zig\");\nconst gc = @import(\"rts/gc.zig\");\n\nexport fn base64Q_en"
},
{
"path": "base/acton.zig",
"chars": 4778,
"preview": "const std = @import(\"std\");\nconst expect = std.testing.expect;\nconst c_acton = @cImport({\n @cInclude(\"builtin/builtin"
},
{
"path": "base/builtin/Iterator.c",
"chars": 1680,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/Iterator.h",
"chars": 26,
"preview": "\n$WORD $next(B_Iterator);\n"
},
{
"path": "base/builtin/atom.c",
"chars": 1615,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/atom.h",
"chars": 47,
"preview": "extern struct B_atomG_class B_atomG_methods;\n\n\n"
},
{
"path": "base/builtin/bigint.c",
"chars": 54203,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/bigint.h",
"chars": 795,
"preview": "#include <bsdnt/zz.h>\n\nstruct B_bigint {\n struct B_bigintG_class *$class;\n zz_struct val;\n};\n\n// B_int zz$to$int(z"
},
{
"path": "base/builtin/bool.c",
"chars": 3184,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/bool.h",
"chars": 183,
"preview": "struct B_bool {\n struct B_boolG_class *$class;\n long val;\n};\n\nB_bool toB_bool(long b);\nlong fromB_bool(B_bool b);\n\next"
},
{
"path": "base/builtin/box.c",
"chars": 2940,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/box.h",
"chars": 498,
"preview": "struct $Box;\n\ntypedef struct $Box *$Box;\n\nstruct $Box {\n struct $BoxG_class *$class;\n $WORD val;\n};\n\nstruct $BoxG_"
},
{
"path": "base/builtin/builtin.c",
"chars": 2334,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/builtin.h",
"chars": 2480,
"preview": "#pragma once\n#ifdef __linux__\n#ifndef _GNU_SOURCE\n#define _GNU_SOURCE 1\n#endif\n#endif\n\n#include <stdlib.h>\n#include <std"
},
{
"path": "base/builtin/builtin_functions.c",
"chars": 18828,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/builtin_functions.h",
"chars": 5855,
"preview": "#pragma once\n// #include \"function.h\"\n\n \n// enumerate ////////////////////////////////////////////////////////////\n\nstru"
},
{
"path": "base/builtin/class_hierarchy.c",
"chars": 2919,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/class_hierarchy.h",
"chars": 1301,
"preview": "// Super //////////////////////////////////////////////////////////////\n\n// This is only used for typing the $superclass"
},
{
"path": "base/builtin/common.c",
"chars": 2396,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/common.h",
"chars": 2715,
"preview": "\ntypedef void *$WORD;\n#define B_None ($WORD)0\n\n#define $long long\n#define $int64 int64_t\n\nvoid $default__init__($WORD);\n"
},
{
"path": "base/builtin/complex.c",
"chars": 11585,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/complx.h",
"chars": 363,
"preview": "/*\n * This file is deliberately named complx.h to avoid collisions under gcc or\n * clang. Details are murky, is it with "
},
{
"path": "base/builtin/csiphash.c",
"chars": 4373,
"preview": "/* **************************************************************************\n <MIT License>\n Copyright (c) 2013 Marek "
},
{
"path": "base/builtin/dict.c",
"chars": 31607,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/dict.h",
"chars": 2936,
"preview": "typedef struct $table_struct *$table;\n\nstruct B_dict {\n struct B_dictG_class *$class;\n long numelements; "
},
{
"path": "base/builtin/env.c",
"chars": 4602,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/env.h",
"chars": 224,
"preview": "#pragma once\n\nB_Env B_EnvG_newactor (B_WorldCap, B_SysCap, B_list);\n\nB_SysCap B_SysCapG_new();\nB_NoneType B_SysCapD___in"
},
{
"path": "base/builtin/exceptions.c",
"chars": 6203,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/exceptions.h",
"chars": 4382,
"preview": "#include <setjmp.h>\n\nstruct JumpBuf;\ntypedef struct JumpBuf *JumpBuf;\nstruct JumpBuf {\n jmp_buf buf;\n B_BaseExcept"
},
{
"path": "base/builtin/float.c",
"chars": 8550,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/float.h",
"chars": 437,
"preview": "\nstruct B_float {\n struct B_floatG_class *$class;\n double val;\n};\n\n// #define B_RealD_floatG_new(...) B_RealFloatG"
},
{
"path": "base/builtin/function.c",
"chars": 4309,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/function.h",
"chars": 4033,
"preview": "#pragma once\n\nstruct $ContG_class {\n char *$GCINFO;\n int $class_id;\n $SuperG_class $superclass;\n void (*__in"
},
{
"path": "base/builtin/hasher.c",
"chars": 968,
"preview": "B_NoneType B_hasherD___init__ (B_hasher self, B_u64 seed) {\n self->_hasher = zig_hash_wyhash_init(seed ? fromB_u64(se"
},
{
"path": "base/builtin/hasher.h",
"chars": 862,
"preview": "struct B_hasher;\ntypedef struct B_hasher *B_hasher;\n\n/*\nstruct B_hasherG_class {\n char *$GCINFO;\n int $class_id;\n "
},
{
"path": "base/builtin/i16.c",
"chars": 9538,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/i16.h",
"chars": 630,
"preview": "struct B_i16 {\n struct B_i16G_class *$class;\n short val;\n};\n\n \nB_i16 toB_i16(short n);\nshort fromB_i16(B_i16 n);\n\n"
},
{
"path": "base/builtin/i32.c",
"chars": 9410,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/i32.h",
"chars": 617,
"preview": "struct B_i32 {\n struct B_i32G_class *$class;\n int val;\n};\n\n \nB_i32 toB_i32(int n);\nint fromB_i32(B_i32 n);\n\nB_i32 "
},
{
"path": "base/builtin/i8.c",
"chars": 9309,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/i8.h",
"chars": 621,
"preview": "struct B_i8 {\n struct B_i8G_class *$class;\n int8_t val;\n};\n\n \nB_i8 toB_i8(int8_t n);\nint8_t fromB_i8(B_i8 n);\n\nB_i"
},
{
"path": "base/builtin/int.c",
"chars": 9478,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/int.h",
"chars": 709,
"preview": "struct B_int {\n struct B_intG_class *$class;\n int64_t val;\n};\n\n \nB_int toB_int(int64_t n);\nB_int to$int(int64_t n)"
},
{
"path": "base/builtin/list.c",
"chars": 21458,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/list.h",
"chars": 1255,
"preview": " \nstruct B_list {\n struct B_listG_class *$class;\n $WORD *data;\n int length;\n int capacity;\n};\n/*\nextern struct B_Seq"
},
{
"path": "base/builtin/none.c",
"chars": 2264,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/none.h",
"chars": 498,
"preview": "struct B_NoneTypeG_class {\n char *$GCINFO;\n int $class_id;\n $SuperG_class $superclass;\n void (*__init__)(B_N"
},
{
"path": "base/builtin/range.c",
"chars": 5176,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/range.h",
"chars": 151,
"preview": "\nstruct B_range {\n struct B_rangeG_class *$class;\n int64_t nxt;\n int64_t step;\n int64_t remaining;\n};\n\nint64"
},
{
"path": "base/builtin/registration.c",
"chars": 5854,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/registration.h",
"chars": 3758,
"preview": "/* \n * During initialization of an Acton program we need to establish a one-to-one mapping between method tables and non"
},
{
"path": "base/builtin/serialize.c",
"chars": 10318,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/serialize.h",
"chars": 2724,
"preview": "\n\n// Types for serialization ////////////////////////////////////////////////////////////////////////////\n\n\n// The seria"
},
{
"path": "base/builtin/set.c",
"chars": 20731,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/set.h",
"chars": 1227,
"preview": "\ntypedef struct {\n $WORD key;\n long hash; \n} B_setentry;\n\nstruct B_set {\n struct B_setG_class *$class;\n l"
},
{
"path": "base/builtin/slice.c",
"chars": 4476,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/slice.h",
"chars": 216,
"preview": "\nstruct B_slice {\n struct B_sliceG_class *$class;\n int64_t *start;\n int64_t *stop;\n int64_t *step;\n};\n\nvoid normaliz"
},
{
"path": "base/builtin/staticWitnesses.c",
"chars": 24904,
"preview": "struct B_HashableD_bytes B_HashableD_bytesG_instance;\nstruct B_TimesD_bytes B_TimesD_bytesG_instance;\nstruct B_Container"
},
{
"path": "base/builtin/staticWitnesses.h",
"chars": 5568,
"preview": "extern B_HashableD_bytes B_HashableD_bytesG_witness;\nextern B_TimesD_bytes B_TimesD_bytesG_witness;\nextern B_ContainerD_"
},
{
"path": "base/builtin/str.c",
"chars": 140738,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/str.h",
"chars": 4216,
"preview": "struct B_strG_class;\n\nstruct B_str {\n struct B_strG_class *$class;\n int nbytes; // length of str in b"
},
{
"path": "base/builtin/timsort.c",
"chars": 14928,
"preview": "#define SORT_NAME B\n\n#define SORT_TYPE $WORD\n\n/* An implementation of simplified Timsort (no galloping).\n\n * Slightly mo"
},
{
"path": "base/builtin/tuple.c",
"chars": 11456,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/tuple.h",
"chars": 7338,
"preview": "struct B_tupleG_class {\n char *$GCINFO;\n int $class_id;\n $SuperG_class $superclass;\n B_NoneType (*__init__)("
},
{
"path": "base/builtin/u1.c",
"chars": 9040,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/u1.h",
"chars": 610,
"preview": "struct B_u1 {\n struct B_u1G_class *$class;\n uint8_t val;\n};\n\nB_u1 toB_u1(uint8_t n);\nuint8_t fromB_u1(B_u1 n);\n\nB_"
},
{
"path": "base/builtin/u16.c",
"chars": 9397,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/u16.h",
"chars": 681,
"preview": "struct B_u16 {\n struct B_u16G_class *$class;\n unsigned short val;\n};\n\nB_u16 toB_u16(unsigned short n);\nunsigned sh"
},
{
"path": "base/builtin/u32.c",
"chars": 9393,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/u32.h",
"chars": 669,
"preview": "struct B_u32 {\n struct B_u32G_class *$class;\n unsigned int val;\n};\n\nB_u32 toB_u32(unsigned int n);\nunsigned int fr"
},
{
"path": "base/builtin/u64.c",
"chars": 9599,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/u64.h",
"chars": 645,
"preview": "struct B_u64 {\n struct B_u64G_class *$class;\n uint64_t val;\n};\n\nB_u64 toB_u64(uint64_t n);\nuint64_t fromB_u64(B_u6"
},
{
"path": "base/builtin/u8.c",
"chars": 9109,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/builtin/u8.h",
"chars": 624,
"preview": "struct B_u8 {\n struct B_u8G_class *$class;\n uint8_t val;\n};\n\nB_u8 toB_u8(uint8_t n);\nuint8_t fromB_u8(B_u8 n);\n\nB_"
},
{
"path": "base/builtin/utils.c",
"chars": 922,
"preview": "B_list B_mk_list(int len, ...) {\n B_list res = B_listD_new(len);\n res->length = len;\n va_list args;\n va_star"
},
{
"path": "base/builtin/utils.h",
"chars": 121,
"preview": "B_list B_mk_list(int len,...);\n\nB_dict B_mk_dict(int len, B_Hashable w,...);\n\nB_set B_mk_set(int len, B_Hashable w,...);"
},
{
"path": "base/rts/common.c",
"chars": 4250,
"preview": "#include <stdlib.h>\n#include <errno.h>\n\n#ifdef __linux__\n#include <dlfcn.h>\n#endif\n\n#include <mbedtls/platform.h>\n#defin"
},
{
"path": "base/rts/common.h",
"chars": 1535,
"preview": "#pragma once\n#include <stddef.h>\n#include <stdlib.h>\n\n#define GC_THREADS 1\n#ifdef _WIN32\n#include <winsock2.h>\n#endif\n#i"
},
{
"path": "base/rts/gc.zig",
"chars": 5202,
"preview": "const std = @import(\"std\");\nconst assert = std.debug.assert;\nconst testing = std.testing;\nconst mem = std.mem;\nconst All"
},
{
"path": "base/rts/io.c",
"chars": 416,
"preview": "#ifdef ACTON_THREADS\n#define GC_THREADS 1\n#endif\n#include <gc.h>\n\n#include \"io.h\"\n\n#include <uv.h>\n#include <unistd.h>\n\n"
},
{
"path": "base/rts/io.h",
"chars": 373,
"preview": "#pragma once\n\n#ifdef __linux__\n#ifndef _GNU_SOURCE\n#define _GNU_SOURCE 1\n#endif\n#endif\n\n#define GC_THREADS 1\n#include <g"
},
{
"path": "base/rts/log.c",
"chars": 4836,
"preview": "/*\n * Copyright (c) 2020 rxi\n *\n * Permission is hereby granted, free of charge, to any person obtaining a copy\n * of th"
},
{
"path": "base/rts/log.h",
"chars": 1505,
"preview": "/**\n * Copyright (c) 2020 rxi\n *\n * This library is free software; you can redistribute it and/or modify it\n * under the"
},
{
"path": "base/rts/netstring.c",
"chars": 5454,
"preview": "/* Streaming API for netstrings. */\n\n#include <stdio.h>\n#include <string.h>\n#include <stdlib.h>\n#include <ctype.h>\n#incl"
},
{
"path": "base/rts/netstring.h",
"chars": 821,
"preview": "#ifndef __NETSTRING_STREAM_H\n#define __NETSTRING_STREAM_H\n\n#include <string.h>\n\nsize_t netstring_add(char **netstring, c"
},
{
"path": "base/rts/q.c",
"chars": 5140,
"preview": "#include \"rts.h\"\n#include \"q.h\"\n\nstatic inline void spinlock_lock($Lock *f) {\n while (atomic_flag_test_and_set(f) == "
},
{
"path": "base/rts/q.h",
"chars": 345,
"preview": "#pragma once\n\n#define MPMC 2\n\n#include \"rts.h\"\n\n\n#if defined MPMC && MPMC == 3\n// TODO: do atomics!\nstruct mpmcq {\n $"
},
{
"path": "base/rts/rts.c",
"chars": 103282,
"preview": "/*\n * Copyright (C) 2019-2021 Data Ductus AB\n *\n * Redistribution and use in source and binary forms, with or without mo"
},
{
"path": "base/rts/rts.h",
"chars": 8598,
"preview": "#pragma once\n\n#include <stdio.h>\n#include <stdlib.h>\n#include <stdint.h>\n#include <stdbool.h>\n#include <time.h>\n#ifdef A"
},
{
"path": "base/src/__builtin__.act",
"chars": 35778,
"preview": "# Copyright (C) 2019-2021 Data Ductus AB\n#\n# Redistribution and use in source and binary forms, with or without modifica"
},
{
"path": "base/src/__builtin__.ext.c",
"chars": 3819,
"preview": "#include \"rts/rts.c\"\n\nvoid B___ext_init__() {\n\n B_HashableD_bigintG_methods.__eq__ = (B_bool (*)(B_HashableD_bigint, "
},
{
"path": "base/src/acton/rts.act",
"chars": 4342,
"preview": "def gc(cap: SysCap) -> None:\n \"\"\"Collect garbage\n\n Jedi level. This is not the function you are looking for.\n \""
},
{
"path": "base/src/acton/rts.ext.c",
"chars": 6334,
"preview": "#define GC_THREADS 1\n#include <gc.h>\n\n#include <time.h>\n#include <uv.h>\n\n#include \"rts/io.h\"\n#include \"rts/log.h\"\n\nvoid "
},
{
"path": "base/src/argparse.act",
"chars": 24297,
"preview": "\"\"\"Command line argument parsing\n\nThe argparse module provides command-line argument parsing for Acton applications.\nIt "
},
{
"path": "base/src/base64.act",
"chars": 107,
"preview": "def encode(data: bytes) -> bytes:\n NotImplemented\n\ndef decode(data: bytes) -> bytes:\n NotImplemented\n"
},
{
"path": "base/src/base64.ext.c",
"chars": 31,
"preview": "void base64Q___ext_init__() {}\n"
},
{
"path": "base/src/buildy.act",
"chars": 15183,
"preview": "\"\"\"Buildy stuff\n\nOur projects have a built.act and it collides with this module if it would be\ncalled just 'build', so i"
},
{
"path": "base/src/crypto/hash/md5.act",
"chars": 767,
"preview": "class Hasher(object):\n _hasher: u64\n def __init__(self):\n \"\"\"Initialize a new MD5 hashing context\n \""
},
{
"path": "base/src/crypto/hash/md5.ext.c",
"chars": 730,
"preview": "void cryptoQ_hashQ_md5Q___ext_init__() {}\n\nvoid *zig_crypto_hash_md5_init();\nvoid *zig_crypto_hash_md5_update(void *hash"
},
{
"path": "base/src/diff.act",
"chars": 15266,
"preview": "import term\n\n# Implementation of Myers-inspired diff algorithm, which is efficient and produces\n# good results for typic"
},
{
"path": "base/src/file.act",
"chars": 10112,
"preview": "class FileCap():\n def __init__(self, cap: WorldCap):\n pass\n\nclass ReadFileCap():\n def __init__(self, cap: F"
},
{
"path": "base/src/file.ext.c",
"chars": 18554,
"preview": "#define GC_THREADS 1\n#include \"gc.h\"\n\n#include <stdio.h>\n#include <string.h>\n#include <sys/file.h>\n\n#include <uv.h>\n#inc"
},
{
"path": "base/src/fs.act",
"chars": 7157,
"preview": "\ndef path_separator() -> str:\n \"\"\"Get the path separator for the current platform.\"\"\"\n # TODO: Implement this func"
},
{
"path": "base/src/hash/wyhash.act",
"chars": 681,
"preview": "class Hasher(object):\n _hasher: u64\n def __init__(self, seed: u64 = 0):\n \"\"\"Initialize a new MD5 hashing co"
},
{
"path": "base/src/hash/wyhash.ext.c",
"chars": 877,
"preview": "void hashQ_wyhashQ___ext_init__() {}\n\nvoid *zig_hash_wyhash_init(uint64_t seed);\nvoid zig_hash_wyhash_update(void *hashe"
},
{
"path": "base/src/http.act",
"chars": 28407,
"preview": "import acton.rts\nimport json\nimport logging\nimport net\nimport time\n\nresponses : dict[int,bytes] = {\n 100: b\"Continue\""
},
{
"path": "base/src/json.act",
"chars": 1463,
"preview": "actor Json():\n \"\"\"JSON actor for distributed async processing\n\n This actor can be used to process JSON data in a a"
},
{
"path": "base/src/json.ext.c",
"chars": 13768,
"preview": "\n#include \"../rts/io.h\"\n#include \"../rts/log.h\"\n#include \"yyjson.h\"\n\nstatic void *my_malloc(void *ctx, size_t size) {\n "
},
{
"path": "base/src/logging.act",
"chars": 11000,
"preview": "r\"\"\"Advanced actor based logging\n\nThere are three main components to the logging system:\n- Loggers: each actor that want"
},
{
"path": "base/src/logging.ext.c",
"chars": 347,
"preview": "\nvoid loggingQ___ext_init__() {}\n\nB_int loggingQ_MessageD__get_actor_id (loggingQ_Message self) {\n $Actor actor_self "
},
{
"path": "base/src/math.act",
"chars": 3034,
"preview": "# Copyright (C) 2019-2021 Data Ductus AB\n#\n# Redistribution and use in source and binary forms, with or without modifica"
},
{
"path": "base/src/math.ext.c",
"chars": 1703,
"preview": "B_float mathQ_RealFunsD_floatD_sqrt(mathQ_RealFunsD_float wit, B_float x) {\n return to$float(sqrt(x->val));\n}\nB_float m"
},
{
"path": "base/src/net.act",
"chars": 13137,
"preview": "\"\"\"Network IO\n\"\"\"\n\nclass NetCap():\n \"\"\"Capability to access network\"\"\"\n def __init__(self, cap: WorldCap):\n "
},
{
"path": "base/src/net.ext.c",
"chars": 43213,
"preview": "#define GC_THREADS 1\n#ifdef _WIN32\n#include <winsock2.h>\n#endif\n#include <gc.h>\n\n#include <stdint.h>\n#include <tlsuv/tls"
},
{
"path": "base/src/process.act",
"chars": 5296,
"preview": "\"\"\"Constructs for spawning and interacting with sub-processes\n\"\"\"\n\n\ndef _get_env_path() -> ?str:\n \"\"\"Get the PATH env"
},
{
"path": "base/src/process.ext.c",
"chars": 8699,
"preview": "#include \"rts/common.h\"\n\n#include <uv.h>\n#include \"../rts/io.h\"\n#include \"../rts/log.h\"\n\nvoid processQ___ext_init__() {\n"
},
{
"path": "base/src/qcheck.act",
"chars": 3198,
"preview": "from random import *\n\ndef qcheck_int_1(name: str, prop: (int) -> bool, verbose = False)->int:\n print(\"Testing\",name)\n"
},
{
"path": "base/src/random.act",
"chars": 2352,
"preview": "# TODO: randint should not be pure!!! but what should it be?\ndef randint(min: int, max: int) -> int:\n NotImplemented\n"
},
{
"path": "base/src/random.ext.c",
"chars": 1817,
"preview": "#include <stdlib.h>\n\nvoid randomQ___ext_init__() {\n // seed the random number generator with nanoseconds since the ep"
},
{
"path": "base/src/re.act",
"chars": 3812,
"preview": "\n#class Pattern():\n# pass\n#\n#class Or(Pattern):\n# def __init__(self, p: list[Pattern]):\n# self.p = p\n#\n# "
}
]
// ... and 891 more files (download for full content)
About this extraction
This page contains the full source code of the actonlang/acton GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 1091 files (9.2 MB), approximately 2.5M tokens, and a symbol index with 3925 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.