A11 (C++ runtime)
Native C++ implementation of the A11 streaming action runtime
Loading...
Searching...
No Matches
resolve.cc File Reference
#include "a11/flow/resolve.h"
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <limits>
#include <optional>
#include <ranges>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
#include <absl/container/flat_hash_map.h>
#include <absl/container/flat_hash_set.h>
#include <absl/strings/ascii.h>
#include <absl/strings/numbers.h>
#include <absl/strings/str_cat.h>
#include <absl/strings/str_join.h>
#include <absl/strings/str_replace.h>
#include <absl/time/time.h>
#include <absl/types/span.h>
#include <cmath>
#include <nlohmann/json.hpp>
#include "a11/flow/contract.h"
#include "a11/flow/diagnostic.h"
#include "a11/flow/emit_json.h"
#include "a11/flow/pattern.h"
#include "a11/flow/plan.h"
#include "a11/flow/syntax.h"
#include "a11/flow/temporal.h"
#include "a11/flow/vocabulary.h"
#include "absl/strings/match.h"

Namespaces

namespace  a11
 
namespace  a11::flow
 

Functions

std::string_view a11::flow::SymbolKindName (SymbolKind kind)
 The name of a symbol kind, for a message and for the JSON.
 
ResolveResult a11::flow::Resolve (std::string_view source, const ParseResult &parsed, bool build_graph, const Program *context, CompilationLimits limits, CompilationBudget *budget)
 

Variable Documentation

◆ carried

bool carried = false

◆ carries

std::string carries

◆ carries_a_value

bool carries_a_value = true

False for a for. What <- checks.

◆ has_carry_name

bool has_carry_name = false

◆ has_front

bool has_front = false

Whether a counted skip may take values off the front of it: only a stream that is genuinely produced somewhere has a front.

◆ kind

Kind kind = Kind::kUnknown

◆ label

std::string label

◆ names

std::vector<std::string> names

◆ node

graph::RefId node = graph::kNone

Graph ref for this result, or [graph::kNone] without a resolved ref.

◆ outer_values

absl::flat_hash_map<std::string, size_t> outer_values

◆ parallel

int parallel = 1

How many passes may run at once, so until can refuse to be written on a loop where "the pass that just finished" names several passes.

◆ parent

const Scope* parent = nullptr

◆ readable

bool readable = true

◆ shape

std::string shape {}

Declared shape of stream values, retained through compatible stages.

◆ step

graph::StepId step = graph::kNone

The graph step it is, so <- and until can fill it in.

◆ stopped

bool stopped = false

◆ subject

std::string subject

What to call it in the message: ‘'Source’, orthe pattern`.

◆ symbol

size_t symbol = kNoSymbol

The symbol this reads through, for the usage counts.

◆ tolerant

bool tolerant = false

For an outcome: whether a bad one is the flow's business or the subject's.

True where the subject is a try call, or a barrier on one.

◆ writable

bool writable = false