package analysis

import "github.com/azin-lang/Azin/internal/codegen/c/analysis"

Index

Constants

const (
	Stdio  = "stdio.h"
	Stdlib = "stdlib.h"
	String = "string.h"
	Math   = "math.h"
)

Variables

var Builtins = map[string]Builtin{
	"printf":   {Stdio},
	"fprintf":  {Stdio},
	"sprintf":  {Stdio},
	"snprintf": {Stdio},
	"scanf":    {Stdio},
	"sscanf":   {Stdio},
	"fopen":    {Stdio},
	"fclose":   {Stdio},
	"fread":    {Stdio},
	"fwrite":   {Stdio},
	"fflush":   {Stdio},
	"fseek":    {Stdio},
	"ftell":    {Stdio},
	"puts":     {Stdio},
	"fgets":    {Stdio},
	"fputs":    {Stdio},
	"getchar":  {Stdio},
	"putchar":  {Stdio},

	"malloc":   {Stdlib},
	"calloc":   {Stdlib},
	"realloc":  {Stdlib},
	"free":     {Stdlib},
	"exit":     {Stdlib},
	"abs":      {Stdlib},
	"atoi":     {Stdlib},
	"atof":     {Stdlib},
	"atol":     {Stdlib},
	"atoll":    {Stdlib},
	"strtol":   {Stdlib},
	"strtoll":  {Stdlib},
	"strtoul":  {Stdlib},
	"strtoull": {Stdlib},
	"strtod":   {Stdlib},
	"strtof":   {Stdlib},

	"strlen":  {String},
	"strcpy":  {String},
	"strcmp":  {String},
	"memset":  {String},
	"memcpy":  {String},
	"strncpy": {String},
	"strcat":  {String},
	"strncat": {String},
	"strncmp": {String},
	"strchr":  {String},
	"strrchr": {String},
	"strstr":  {String},
	"strtok":  {String},
	"memmove": {String},
	"memcmp":  {String},

	"sqrt":  {Math},
	"pow":   {Math},
	"sin":   {Math},
	"cos":   {Math},
	"floor": {Math},
	"ceil":  {Math},
	"fabs":  {Math},
}

Functions

func FunctionName

func FunctionName(fn *ast.FuncStmt) string

Types

type Analyzer

type Analyzer struct {
	Transpiler Transpiler
	Errors     []error

	Functions map[string]FuncInfo
	Structs   map[string]*ast.StructStmt
	Enums     map[string]*ast.EnumStmt

	Calls              map[string]map[string]struct{}
	ReachableFunctions map[string]struct{}
	TypeDependencies   map[*types.TypeInfo]map[*types.TypeInfo]struct{}
	ReachableTypes     map[*types.TypeInfo]struct{}

	Variables map[string]map[string]int
}
func New
func New(t Transpiler) *Analyzer
func (*Analyzer) Analyze
func (a *Analyzer) Analyze(program *ast.Program)
func (*Analyzer) AnalyzeUsage
func (a *Analyzer) AnalyzeUsage(program *ast.Program)
func (*Analyzer) BuildCallGraph
func (a *Analyzer) BuildCallGraph()
func (*Analyzer) CollectFunctions
func (a *Analyzer) CollectFunctions(program *ast.Program)
func (*Analyzer) CollectImports
func (a *Analyzer) CollectImports(program *ast.Program)
func (*Analyzer) CollectReachableTypes
func (a *Analyzer) CollectReachableTypes(program *ast.Program)

CollectReachableTypes scans the AST after dead functions and dead variables have been pruned, marking only remaining types (and their field dependencies) as reachable.

func (*Analyzer) CollectTypes
func (a *Analyzer) CollectTypes(program *ast.Program)
func (*Analyzer) ComputeReachability
func (a *Analyzer) ComputeReachability()
func (*Analyzer) HasErrors
func (a *Analyzer) HasErrors() bool
func (*Analyzer) MarkTypeUsed
func (a *Analyzer) MarkTypeUsed(t *types.TypeInfo)

MarkTypeUsed resolves a struct or enum type and recursively marks all of its dependent types as used.

func (*Analyzer) RemoveUnusedFunctions
func (a *Analyzer) RemoveUnusedFunctions(program *ast.Program)
func (*Analyzer) RemoveUnusedTypes
func (a *Analyzer) RemoveUnusedTypes(program *ast.Program)
func (*Analyzer) RemoveUnusedVariables
func (a *Analyzer) RemoveUnusedVariables(program *ast.Program)
func (*Analyzer) ReportError
func (a *Analyzer) ReportError(format string, args ...any)
func (*Analyzer) Reset
func (a *Analyzer) Reset()
func (*Analyzer) Walk
func (a *Analyzer) Walk(program *ast.Program)
func (*Analyzer) WalkMain
func (a *Analyzer) WalkMain(program *ast.Program)

type Builtin

type Builtin struct {
	Include string
}
func LookupBuiltin
func LookupBuiltin(name string) (Builtin, bool)

type FuncInfo

type FuncInfo struct {
	Stmt  *ast.FuncStmt
	Index int
}

type Transpiler

type Transpiler interface {
	RequireInclude(string)
	SetFunctionIndex(string, int)
	FunctionIndex(string) (int, bool)
	RegisterForwardDeclaration(string, *ast.FuncStmt)
	SetEnum(string)
}