Functions — github.com/VictorTaelin/Interaction-Calculus

CodeHub MCPcopy Create free account

hub / github.com/VictorTaelin/Interaction-Calculus / functions

Functions107 in github.com/VictorTaelin/Interaction-Calculus

⨍ Functions 107◇ Types & classes 1

↓ 55 callersFunctionic_alloc

Allocate n consecutive terms in memory. @param ic The IC context @param n Number of terms to allocate @return Location in the heap Does NOT bound chec

↓ 33 callersFunctionic_make_term

Create a term with the given tag and value. @param tag Term type tag (includes label for SUP, CX, CY) @param val Value/pointer into the heap @return T

↓ 27 callersFunctionexpect

src/parse.c:120

↓ 20 callersFunctionic_make_sup

Helper to create a term with the appropriate superposition tag for a label @param lab Label value (0-3) @param val Value/pointer into the heap @return

↓ 17 callersFunctionic_make_co0

Helper to create a DP0 term with the appropriate tag for a label @param lab Label value (0-3) @param val Value/pointer into the heap @return The const

↓ 17 callersFunctionic_make_co1

Helper to create a DP1 term with the appropriate tag for a label @param lab Label value (0-3) @param val Value/pointer into the heap @return The const

↓ 16 callersFunctionparse_error

src/parse.c:108

↓ 15 callersFunctionic_make_sub

Create a substitution term. @param term The term to convert to a substitution @return The term with its substitution bit set

↓ 14 callersFunctionparse_term

src/parse.c:421

↓ 12 callersFunctionpeek_char

src/parse.c:167

↓ 9 callersFunctionnext_char

src/parse.c:156

↓ 9 callersFunctionstarts_with_dollar

Helper functions

↓ 8 callersFunctionstore_term

src/parse.c:175

↓ 6 callersFunctionic_clear_sub

Remove the substitution bit from a term. @param term The term to clear the substitution bit from @return The term with its substitution bit cleared

↓ 5 callersFunctionfind_or_add_global_var

↓ 5 callersFunctionget_var_name

Get a variable name from the table

↓ 5 callersFunctionic_is_era

Check if a term is an erasure @param term The term to check @return True if the term is an erasure, false otherwise

↓ 5 callersFunctionparse_name

src/parse.c:140

↓ 5 callersFunctionskip

src/parse.c:192

↓ 4 callersFunctionic_make_era

Helper to create an erasure term @return An erasure term (ERA tag with no value)

↓ 4 callersFunctionic_metal_available

↓ 4 callersFunctionic_normal

Recursive implementation of normal form reduction

↓ 4 callersFunctionic_whnf

Reduce a term to weak head normal form (WHNF). @param ic The IC context @param term The term to reduce @return The term in WHNF

↓ 4 callersFunctionpop_lexical_binder

↓ 4 callersFunctionpush_lexical_binder

↓ 3 callersFunctionadd_variable

Add a variable to the table and return its name

↓ 3 callersFunctionnormalize_term

Normalize a term based on mode flags

↓ 3 callersFunctionparse_string

src/parse.c:467

↓ 3 callersFunctionparse_uint

src/parse.c:179

↓ 3 callersFunctionprint_usage

Print command-line usage

↓ 2 callersFunctionconsume

Parse helper functions

↓ 2 callersFunctionic_dup_era

&L{r,s} = *; K -------------- DUP-ERA r <- s <- K

↓ 2 callersFunctionic_free

Free all resources associated with an IC context. @param ic The IC context to free

↓ 2 callersFunctionic_make_num

Helper to create a number term @param val The numeric value @return A number term

↓ 2 callersFunctionic_make_suc

Helper to create a successor term @param val Pointer to the successor node @return A successor term

↓ 2 callersFunctionic_normal_metal

↓ 2 callersFunctionic_suc

Allocs a Suc node

↓ 2 callersFunctionic_swi

Allocs a Swi node

↓ 2 callersFunctionprocess_term

Process and print results of term normalization

↓ 2 callersFunctionshow_term

Display a term to the specified output stream

↓ 2 callersFunctionshow_term_namespaced

Display a term to the specified output stream with a prefix for variable names

↓ 2 callersFunctionstringify_term

Stringify a term

↓ 2 callersFunctionterm_to_string_internal

Convert a term to its string representation with optional namespace prefix

↓ 1 callersFunctionassign_var_ids

Assign IDs to variables and register duplications

↓ 1 callersFunctionbenchmark_term

Benchmark normalization performance over 1 second

↓ 1 callersFunctioncheck_utf8

src/parse.c:212

↓ 1 callersFunctionconsume_utf8

src/parse.c:217

↓ 1 callersFunctionfind_lexical_binder

↓ 1 callersFunctionfree_dup_table

Free duplication table

↓ 1 callersFunctionfree_var_table

Free variable name table

↓ 1 callersFunctionic_app_era

(* a) ----- APP-ERA

↓ 1 callersFunctionic_app_lam

(λx.f a) -------- APP-LAM x <- a f

↓ 1 callersFunctionic_app_sup

(&L{a,b} c) ----------------- APP-SUP &L{c0,c1} = c; &L{(a c0),(b c1)}

↓ 1 callersFunctionic_collapse_dups

src/collapse.c:445

↓ 1 callersFunctionic_collapse_sups

src/collapse.c:374

↓ 1 callersFunctionic_default_new

Create a new IC context with default heap and stack sizes. @return A new IC context or NULL if allocation failed

↓ 1 callersFunctionic_dup_app

!&L{a0,a1} = (f x); K --------------------- DUP-APP a0 <- (f0 x0) a1 <- (f1 x1) !&L{f0,f1} = f; !&L{x0,x1} = x; K

src/collapse.c:226

↓ 1 callersFunctionic_dup_lam

&L{r,s} = λx.f; K ----------------- DUP-LAM r <- λx0.f0 s <- λx1.f1 x <- &L{x0,x1} &L{f0,f1} = f; K

↓ 1 callersFunctionic_dup_num

&L{x,y} = N; K -------------- DUP-NUM x <- N y <- N K

↓ 1 callersFunctionic_dup_sup

&L{x,y} = &R{a,b}; K -------------------- DUP-SUP (if different labels) x <- &R{a0,b0} y <- &R{a1,b1} &L{a0,a1} = a &L{b0,b1} = b K

↓ 1 callersFunctionic_dup_var

!&L{x0,x1} = x; K ----------------- DUP-VAR x0 <- x x1 <- x K

src/collapse.c:212

↓ 1 callersFunctionic_era_app

(f *) ----- ERA-APP

src/collapse.c:34

↓ 1 callersFunctionic_era_lam

λx. ------ ERA-LAM x <-

src/collapse.c:19

↓ 1 callersFunctionic_new

Create a new IC context with the specified heap and stack sizes. @param heap_size Number of terms in the heap @param stack_size Number of terms in the

↓ 1 callersFunctionic_suc_era

↓ 1 callersFunctionic_suc_num

+N --- SUC-NUM N+1

↓ 1 callersFunctionic_suc_sup

+&L{x,y} --------- SUC-SUP &L{+x,+y}

↓ 1 callersFunctionic_sup_app

(f &L{x0,x1}) ------------------- SUP-APP !&L{f0,f1} = f &L{(f0 x0),(f1 x1)}

src/collapse.c:86

↓ 1 callersFunctionic_sup_lam

λx.&L{f0,f1} ----------------- SUP-LAM x <- &L{x0,x1} &L{λx0.f0,λx1.f1}

src/collapse.c:45

↓ 1 callersFunctionic_sup_sup_x

&R{&L{x0,x1},y} ----------------------- SUP-SUP-X (if R>L) !&R{y0,y1} = y; &L{&R{x0,x1},&R{y0,y1}}

src/collapse.c:127

↓ 1 callersFunctionic_sup_sup_y

&R{x,&L{y0,y1}} ----------------------- SUP-SUP-Y (if R>L) !&R{x0,x1} = x; &L{&R{x0,x1},&R{y0,y1}}

src/collapse.c:169

↓ 1 callersFunctionic_sup_swi_s

~N{0:z;+:&0{s0,s1};} --------------------------------- SUP-SWI-S !&L{N0,N1} = N; !&L{Z0,Z1} = Z; &L{~N0{0:z0;+:S0},~N1{0:z1;+:S1}}

src/collapse.c:327

↓ 1 callersFunctionic_sup_swi_z

~N{0:&L{z0,z1};+:s;} --------------------------------- SUP-SWI-Z !&L{N0,N1} = N; !&L{S0,S1} = S; &L{~N0{0:z0;+:S0},~N1{0:z1;+:S1}}

src/collapse.c:279

↓ 1 callersFunctionic_swi_era

?*{0:z;+:s;} ------------ SWI-ERA

↓ 1 callersFunctionic_swi_num

?N{0:z;+:s;} ------------ SWI-NUM (if N==0) z

↓ 1 callersFunctionic_swi_sup

?&L{x,y}{0:z;+:s;} --------------------------------- SWI-SUP &L{z0,z1} = z; &L{s0,s1} = s; &L{?x{0:z0;+:s0;},?y{0:z1;+:s1;}}

↓ 1 callersFunctionindex_to_var_name

Convert an index to an alphabetic variable name (a, b, c, ..., z, aa, ab, ...)

↓ 1 callersFunctioninit_dup_table

Initialize duplication table

↓ 1 callersFunctioninit_parser

src/parse.c:130

↓ 1 callersFunctioninit_var_table

Initialize variable name table

↓ 1 callersFunctionmove_term

↓ 1 callersFunctionparse_file

src/parse.c:476

↓ 1 callersFunctionparse_term_alloc

src/parse.c:461

↓ 1 callersFunctionparse_term_app

src/parse.c:285

↓ 1 callersFunctionparse_term_dup

src/parse.c:311

↓ 1 callersFunctionparse_term_era

src/parse.c:358

↓ 1 callersFunctionparse_term_lam

src/parse.c:256

↓ 1 callersFunctionparse_term_let

src/parse.c:392

↓ 1 callersFunctionparse_term_num

src/parse.c:363

↓ 1 callersFunctionparse_term_suc

src/parse.c:368

↓ 1 callersFunctionparse_term_sup

src/parse.c:299

↓ 1 callersFunctionparse_term_swi

src/parse.c:375

↓ 1 callersFunctionparse_term_var

Term parsing functions

src/parse.c:224

↓ 1 callersFunctionregister_duplication

Register a duplication in the table

↓ 1 callersFunctionresolve_global_vars

↓ 1 callersFunctionstringify_duplications

Stringify duplications

↓ 1 callersFunctionterm_to_string

Convert a term to its string representation

↓ 1 callersFunctionterm_to_string_namespaced

Convert a term to its string representation with a prefix for variable names

↓ 1 callersFunctiontest

Run default test term

Functionget_num_val

Helper functions for numeric operations

next →1–100 of 107, ranked by callers