From 133922f5c2311736c32bf1de5b9888510e41cb28 Mon Sep 17 00:00:00 2001
From: Robert-M-Lucas <robert-m-lucas@example.com>
Date: Sun, 16 Jun 2024 18:25:10 +0100
Subject: [PATCH] Printing and function calls

---
 .idea/workspace.xml                           |  68 ++++----
 build/out.asm                                 | 145 ++++++++++++++++--
 build/out.o                                   | Bin 688 -> 1712 bytes
 build/out.out                                 | Bin 16512 -> 16768 bytes
 main.why                                      |  22 ++-
 src/root/builtin/functions/mod.rs             |   0
 src/root/builtin/mod.rs                       |  21 ++-
 src/root/builtin/{ => types}/int/add.rs       |   8 +-
 src/root/builtin/{ => types}/int/mod.rs       |  17 +-
 src/root/builtin/types/int/p_sub.rs           |  45 ++++++
 src/root/builtin/types/int/printi.rs          |  64 ++++++++
 src/root/builtin/{ => types}/int/sub.rs       |   8 +-
 src/root/builtin/types/mod.rs                 |   1 +
 src/root/compiler/assembly/utils.rs           |  12 --
 src/root/compiler/compile.rs                  |  21 ++-
 src/root/compiler/compile_evaluable.rs        | 112 ++++++++++----
 src/root/compiler/compile_function.rs         |  27 ++--
 src/root/compiler/compile_function_call.rs    |  17 +-
 src/root/compiler/global_tracker.rs           |  32 ++++
 src/root/compiler/mod.rs                      |   3 +-
 .../parser/parse_function/parse_literal.rs    |   2 +-
 src/root/shared/common.rs                     |  14 ++
 types.toml                                    |   7 +
 23 files changed, 505 insertions(+), 141 deletions(-)
 create mode 100644 src/root/builtin/functions/mod.rs
 rename src/root/builtin/{ => types}/int/add.rs (90%)
 rename src/root/builtin/{ => types}/int/mod.rs (74%)
 create mode 100644 src/root/builtin/types/int/p_sub.rs
 create mode 100644 src/root/builtin/types/int/printi.rs
 rename src/root/builtin/{ => types}/int/sub.rs (90%)
 create mode 100644 src/root/builtin/types/mod.rs
 create mode 100644 src/root/compiler/global_tracker.rs

diff --git a/.idea/workspace.xml b/.idea/workspace.xml
index a777d00..ff2ef1e 100644
--- a/.idea/workspace.xml
+++ b/.idea/workspace.xml
@@ -8,22 +8,28 @@
   </component>
   <component name="ChangeListManager">
     <list default="true" id="6ca282eb-dc8c-4af0-945c-cd77d70c6194" name="Changes" comment="Improved operator support">
-      <change afterPath="$PROJECT_DIR$/src/root/builtin/int/sub.rs" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/src/root/builtin/functions/mod.rs" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/src/root/builtin/types/int/p_sub.rs" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/src/root/builtin/types/int/printi.rs" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/src/root/builtin/types/mod.rs" afterDir="false" />
+      <change afterPath="$PROJECT_DIR$/src/root/compiler/global_tracker.rs" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/.idea/workspace.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/workspace.xml" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/build/out.asm" beforeDir="false" afterPath="$PROJECT_DIR$/build/out.asm" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/build/out.o" beforeDir="false" afterPath="$PROJECT_DIR$/build/out.o" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/build/out.out" beforeDir="false" afterPath="$PROJECT_DIR$/build/out.out" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/main.why" beforeDir="false" afterPath="$PROJECT_DIR$/main.why" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/root/builtin/int/add.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/builtin/int/add.rs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/root/builtin/int/mod.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/builtin/int/mod.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/builtin/int/add.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/builtin/types/int/add.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/builtin/int/mod.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/builtin/types/int/mod.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/builtin/int/sub.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/builtin/types/int/sub.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/builtin/mod.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/builtin/mod.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/compiler/assembly/utils.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/compiler/assembly/utils.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/compiler/compile.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/compiler/compile.rs" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/src/root/compiler/compile_evaluable.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/compiler/compile_evaluable.rs" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/src/root/compiler/compile_function.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/compiler/compile_function.rs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/root/errors/evaluable_errors.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/errors/evaluable_errors.rs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/root/name_resolver/resolve_function_signatures.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/name_resolver/resolve_function_signatures.rs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/root/parser/parse_function.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/parse_function.rs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/root/parser/parse_parameters.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/parse_parameters.rs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/src/root/parser/parse_struct.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/parse_struct.rs" afterDir="false" />
-      <change beforePath="$PROJECT_DIR$/todo.txt" beforeDir="false" afterPath="$PROJECT_DIR$/todo.txt" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/compiler/compile_function_call.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/compiler/compile_function_call.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/compiler/mod.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/compiler/mod.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/parser/parse_function/parse_literal.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/parser/parse_function/parse_literal.rs" afterDir="false" />
+      <change beforePath="$PROJECT_DIR$/src/root/shared/common.rs" beforeDir="false" afterPath="$PROJECT_DIR$/src/root/shared/common.rs" afterDir="false" />
       <change beforePath="$PROJECT_DIR$/types.toml" beforeDir="false" afterPath="$PROJECT_DIR$/types.toml" afterDir="false" />
     </list>
     <option name="SHOW_DIALOG" value="false" />
@@ -71,32 +77,34 @@
     <option name="hideEmptyMiddlePackages" value="true" />
     <option name="showLibraryContents" value="true" />
   </component>
-  <component name="PropertiesComponent"><![CDATA[{
-  "keyToString": {
-    "Cargo.Run whython-8.executor": "Run",
-    "RunOnceActivity.OpenProjectViewOnStart": "true",
-    "RunOnceActivity.ShowReadmeOnStart": "true",
-    "RunOnceActivity.rust.reset.selective.auto.import": "true",
-    "git-widget-placeholder": "master",
-    "ignore.virus.scanning.warn.message": "true",
-    "last_opened_file_path": "/home/robertlucas/RustroverProjects/whython-8/src/root/builtin/int",
-    "node.js.detected.package.eslint": "true",
-    "node.js.detected.package.tslint": "true",
-    "node.js.selected.package.eslint": "(autodetect)",
-    "node.js.selected.package.tslint": "(autodetect)",
-    "nodejs_package_manager_path": "npm",
-    "org.rust.cargo.project.model.PROJECT_DISCOVERY": "true",
-    "org.rust.cargo.project.model.impl.CargoExternalSystemProjectAware.subscribe.first.balloon": "",
-    "org.rust.first.attach.projects": "true",
-    "settings.editor.selected.configurable": "preferences.pluginManager",
-    "vue.rearranger.settings.migration": "true"
+  <component name="PropertiesComponent">{
+  &quot;keyToString&quot;: {
+    &quot;Cargo.Run whython-8.executor&quot;: &quot;Run&quot;,
+    &quot;RunOnceActivity.OpenProjectViewOnStart&quot;: &quot;true&quot;,
+    &quot;RunOnceActivity.ShowReadmeOnStart&quot;: &quot;true&quot;,
+    &quot;RunOnceActivity.rust.reset.selective.auto.import&quot;: &quot;true&quot;,
+    &quot;git-widget-placeholder&quot;: &quot;master&quot;,
+    &quot;ignore.virus.scanning.warn.message&quot;: &quot;true&quot;,
+    &quot;last_opened_file_path&quot;: &quot;/home/robertlucas/RustroverProjects/whython-8/src/root/builtin/int&quot;,
+    &quot;node.js.detected.package.eslint&quot;: &quot;true&quot;,
+    &quot;node.js.detected.package.tslint&quot;: &quot;true&quot;,
+    &quot;node.js.selected.package.eslint&quot;: &quot;(autodetect)&quot;,
+    &quot;node.js.selected.package.tslint&quot;: &quot;(autodetect)&quot;,
+    &quot;nodejs_package_manager_path&quot;: &quot;npm&quot;,
+    &quot;org.rust.cargo.project.model.PROJECT_DISCOVERY&quot;: &quot;true&quot;,
+    &quot;org.rust.cargo.project.model.impl.CargoExternalSystemProjectAware.subscribe.first.balloon&quot;: &quot;&quot;,
+    &quot;org.rust.first.attach.projects&quot;: &quot;true&quot;,
+    &quot;settings.editor.selected.configurable&quot;: &quot;preferences.pluginManager&quot;,
+    &quot;vue.rearranger.settings.migration&quot;: &quot;true&quot;
   }
-}]]></component>
+}</component>
   <component name="RecentsManager">
     <key name="CopyFile.RECENT_KEYS">
       <recent name="$PROJECT_DIR$/src/root/builtin/int" />
     </key>
     <key name="MoveFile.RECENT_KEYS">
+      <recent name="$PROJECT_DIR$/src/root/builtin/types/int" />
+      <recent name="$PROJECT_DIR$/src/root/builtin/types" />
       <recent name="$PROJECT_DIR$/src/root/builtin/int" />
       <recent name="$PROJECT_DIR$/reference" />
     </key>
@@ -180,6 +188,8 @@
       <workItem from="1717823326339" duration="27000" />
       <workItem from="1717823358306" duration="20000" />
       <workItem from="1717823384677" duration="3880000" />
+      <workItem from="1717830463295" duration="1441000" />
+      <workItem from="1718550169655" duration="6286000" />
     </task>
     <task id="LOCAL-00001" summary="Changes">
       <option name="closed" value="true" />
diff --git a/build/out.asm b/build/out.asm
index f5381a2..77f19a6 100644
--- a/build/out.asm
+++ b/build/out.asm
@@ -1,35 +1,146 @@
     global main
 
-    section .text
+section .text
 
-_1:
+main:
+    push rbp
+    mov rbp, rsp
+    
+    mov qword [rbp-8], 3
+    mov rax, qword [rbp-8]
+    mov qword [rbp-16], rax
+    push 0
+    mov rdi, __10_fstr
+    mov rsi, [rbp-16]
+    mov al, 0
+    sub rsp, 16
+    extern printf
+    call printf
+    add rsp, 16
+    
+    mov rax, qword [rbp-8]
+    mov qword [rbp-24], rax
+    push 0
+    mov rdi, __10_fstr
+    mov rsi, [rbp-24]
+    mov al, 0
+    sub rsp, 24
+    extern printf
+    call printf
+    add rsp, 24
+    
+    mov rax, qword [rbp-8]
+    mov qword [rbp-32], rax
+    push 0
+    mov rdi, __10_fstr
+    mov rsi, [rbp-32]
+    mov al, 0
+    sub rsp, 32
+    extern printf
+    call printf
+    add rsp, 32
+    
+    mov rax, qword [rbp-8]
+    mov qword [rbp-40], rax
+    push 0
+    mov rdi, __10_fstr
+    mov rsi, [rbp-40]
+    mov al, 0
+    sub rsp, 40
+    extern printf
+    call printf
+    add rsp, 40
+    
+    mov rax, qword [rbp-8]
+    mov qword [rbp-48], rax
+    push 0
+    mov rdi, __10_fstr
+    mov rsi, [rbp-48]
+    mov al, 0
+    sub rsp, 48
+    extern printf
+    call printf
+    add rsp, 48
+    
+    mov rax, qword [rbp-8]
+    mov qword [rbp-56], rax
+    push 0
+    mov rdi, __10_fstr
+    mov rsi, [rbp-56]
+    mov al, 0
+    sub rsp, 56
+    extern printf
+    call printf
+    add rsp, 56
+    
+    mov rax, qword [rbp-8]
+    mov qword [rbp-64], rax
+    push 0
+    mov rdi, __10_fstr
+    mov rsi, [rbp-64]
+    mov al, 0
+    sub rsp, 64
+    extern printf
+    call printf
+    add rsp, 64
+    
+    mov rax, qword [rbp-8]
+    mov qword [rbp-72], rax
+    push 0
+    mov rdi, __10_fstr
+    mov rsi, [rbp-72]
+    mov al, 0
+    sub rsp, 72
+    extern printf
+    call printf
+    add rsp, 72
+    
+    mov rax, qword [rbp-8]
+    mov qword [rbp-88], rax
+    mov rax, qword [rbp-88]
+    mov qword [rbp-104], rax
+    sub rsp, 104
+    call _2
+    add rsp, 104
+    mov rax, qword [rbp-96]
+    mov qword [rbp-80], rax
+	mov rax, qword [rbp-80]
+	leave
+	ret
+
+_2:
     push rbp
     mov rbp, rsp
     
-    mov qword [rbp-8], 0
     mov rax, qword [rbp+16]
     mov qword [rbp-16], rax
+    mov rax, qword [rbp-16]
+    mov qword [rbp-32], rax
+    sub rsp, 32
+    call _1
+    add rsp, 32
+    mov rax, qword [rbp-24]
+    mov qword [rbp-8], rax
+    mov qword [rbp-32], 1
     mov rax, qword [rbp-8]
-    sub rax, qword [rbp-16]
+    add rax, qword [rbp-32]
     mov qword [rbp+24], rax
     leave
     ret
 
-main:
+_1:
     push rbp
     mov rbp, rsp
     
-    mov qword [rbp-8], -12
-    mov rax, qword [rbp-8]
-    mov qword [rbp-24], rax
-    mov rax, qword [rbp-24]
-    mov qword [rbp-40], rax
-    sub rsp, 40
-    call _1
-    add rsp, 40
-    mov rax, qword [rbp-32]
+    mov rax, qword [rbp+16]
+    mov qword [rbp-8], rax
+    mov rax, qword [rbp+16]
     mov qword [rbp-16], rax
-	mov rax, qword [rbp-16]
-	leave
-	ret
+    mov rax, qword [rbp-8]
+    add rax, qword [rbp-16]
+    mov qword [rbp+24], rax
+    leave
+    ret
 
+section .data
+    __10_fstr db `Integer: %d\n`,0
\ No newline at end of file
diff --git a/build/out.o b/build/out.o
index c6889165121e887af590017941da67199e4debd0..6eed537c0d689d5a9d4ca62bd19a10b9e9b17282 100644
GIT binary patch
literal 1712
zcmbW0L1+_E5QZm7wM7sYQ49#W3SvcwX-`E&b6I(UC&BZwC5eeNsU#b)CxxCu@b0n4
zo+Jkky;)Fbz2zA2vKL_wBJs8dq0YQF&!*FT2tL?1Z~phq&g{H>Z-S?fi-iK%QGkbV
z>{%6{cD&?u4Hls^r~coPa?x{Eh8K-65yg0dTST7_S;>Tj^MYRxKJCj`LJ}5N1ux2h
zE4a_4o*;crG-dS+TB>!4{W9C@X!G&|1>m@A%->n&zl}Tcn+UFQ{96tnhL$q_b2a>~
z4uXtoP@^DI!(jFj)F*WHP@}<Y3~Kv_my)lxzj%zL0!uYkwpf|5L|}==e2e*vO$9d9
z*s{fz8Jh@fqOq#Qs*D{9>`-HC7F%O%Uts$ht68kZ*q*@lG^Q-37~4g=i~W0#-D;&5
zO}APo?w~kEJO27vw|f+L)Miv>XcNT!^rpe79Vv<#o=HOIg?^?=2n~bsiSP_}>}!ai
zS0VAF8#i7wdiVWX^>Y{wP>CC_W2n@lID$&Q)sK5|w2rH-j<M|b8XJ*8b<{s6s%-&&
z9p!-~{imJYDdpUhs~Ri7CjX~4>Kf}GgnmQor*GT^)V-X%m$a^f@~8Ddd!v4Da}Zae
zeg`^Hy9=*+?QYzJa23K82*Z_X*u=J(aC>j5toeIu?<rNbgwO9IGai{RUD-VUjCIL3
o9sHJqf9K$L9Q;QIf8gN1IryIrzR2e#`*WFf`Mq}>`~wI72OLZq(f|Me

literal 688
zcmb<-^>JfjWMqH=Mg}_u1P><4z~F#jLfH-stPD&@qU13_c7ZS(n)U{$BO=kn1<?5H
zKt3~?7>N4-s$UUJ4k`>66$G-d`9c6HSOHbZ0;EBh1Im|x(vm<LoBb1@`o*E@U=+Ij
zp&p%2J&wEn0LgoFy9#)8x_$uCKRmR7bf>Gt$-^)eU;h9950>e4eF3Cj0A+7@G{4b!
zu@fZGd_)5%_yDT?!^y)i3-wA;D@qvjiZhB!ib@ibfUL?~2o2%G)DfUT?q*^5_#c}x
xW-KX&AFL4Fw+swIKyd+}dL?WIfy9zZGjme(^Gi$g5{q*g;td&c6EpJ=iUDjyNPYkS

diff --git a/build/out.out b/build/out.out
index a8f6e15e83f7f2fcea09ae26e55da7fd83964f4a..5822262a034d904d2e634c8105b7ad0936b0bb1f 100755
GIT binary patch
literal 16768
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

delta 2014
zcmZ`)Urbw77(eH>Wxb<}TS_TiVfWUM6=mN3;ZMs3?Io_{E-}tciPMKcQ4tb!A~gnM
z!U$7Ccxm~J*^>Fd^u;$BCT=fd3p)45C?py+?qN-4LYC=B+yn8!`ki~vaSY<u-1D99
z_xrx@{QJ)7$!U6WiWcf4nqm+pc8i@(X4ztp6sbaH4{0oBit=fv4WBOl8r?ZTZDWE$
z4b>;}JVa=s*Z}jYz%QlSb}DUH9ihMDX;!!vaT0p5IFrYjJWl8W_vadx=&IacWhSHn
z&PazJ`@a#d@yKfwb~=vNrf+s0o#}<u&u)EizVyuxb>3r@H{m@;-qnoRG+2;oL;d}u
zBZDvZkLPo5<@;aHjl4mat&gA3JK(UhQ6myzIVt{psQJptm&K291rlk5d1uSw9cM%3
zoa@+}qJg1=jwieZDf=Nx$b%uhT0Lb={jcghe=k2Y3m4pmLCkK}=6x5Ki~0WLyu8GK
z^6jC*^3X%)YSkc@EdQxL-EdI}Q#bskgnW<V5aexNpE>jU+Pmd)`Kl`bvN!s?m2Ebw
zm^0aRb2htSwxFKL)?Z&{uI9JdjR)v$F*DgU)N9E8Vou*{Uc1PM>93m+yv@VcuP<Z5
zbH1wcu8-)PR_kYH!Ol=wFPBrO4b)FVT#E!(?w8AZ5g`Y6C~T`@_}xRywK%W6P&Mb8
zsK>2gvcfA<RE7_{x*8wlY|!$-!s3My;<lUX-CP@x)1$Z-MO~#ySkNQ#4$cfiI2xrU
z9EqybfU)R14lFJ_@E`<ZS$}&Xp*0_U^%c#`<+XU59@pbfwk?jwj!=ju{Ia+<y-<pW
z<UT&tK4yWIXp+S=^DveO$pf6Pu&fcjgputQ{FrE}%yWLi%cc_st@Rm)hYY}2t3Tu+
z1)htqf+Vmb5f52`dE^7ciN(Q0Y#TdiN@|D!tF8V94<S6e<%G?L7VpK41gUMG&qI_g
z4qrjIH6UNM+!XRA6x$+)zPBtN5!Vq-OMbT6YNBX{4e<6ZYD)ZME%PW&fVKy6`*5xr
zslzIHlx;*@L0l|}CnHUW*GN@FY_h<g;Qm|lB%#<InCwN?EA1lgEpvO0;ba$1!5*Ez
za%9lT79i|WZI;&%uaP|DS$+^MPR1CH2O&zsDsto|?L6kTWz1THhp@L`v#>YKE7ffq
z_$(Vhs)Q3AS7{ucO6C`DBozvGQnwZ_bq-Q2<?w;1*X^{kx%oPhkVDkqsKL<+m`Bv)
zsL4?cN(Z9yFh_?W*wq53y1M8maHUJ_IfUbH7V*#t>{IM8mkJJu;~DkZKo#WntMqf2
z>dw#wxYDiC28M)}c$~!JV*DUtnhhL;@P2hJ?X1HyA`b2(?tMy!m(qK8|AcV$CfeZ7
zf??6&5>jkhB3jg~_<JcpDXr4GKr<P7A9^w>t%qD%4R2r!Tat+Tud>*yh2n%#ryBkT
zd+gm2UZP%|o4u$5s1cw}2pSRUfgbD+z>7vC7{UR>o5XUu2Mngj7jVYN_&3=7Mv3v{
c>|yo6A4ZGZ++h*q9E5w4@{Ocz#nDp#1$Jpg4*&oF

diff --git a/main.why b/main.why
index fa319d3..e43546e 100644
--- a/main.why
+++ b/main.why
@@ -1,11 +1,21 @@
-impl int {
-    fn p_sub(self) -> Self {
-        return 0 - self;
-    }
+fn test_two(a: int) -> int {
+    return a + a;
+}
+
+fn test(a: int) -> int {
+    return test_two(a) + 1;
 }
 
 fn main() -> int {
-    let x: int = -12;
-    return -x;
+    let x: int = 3;
+    printi(x);
+    printi(x);
+    printi(x);
+    printi(x);
+    printi(x);
+    printi(x);
+    printi(x);
+    printi(x);
+    return test(x);
 }
 
diff --git a/src/root/builtin/functions/mod.rs b/src/root/builtin/functions/mod.rs
new file mode 100644
index 0000000..e69de29
diff --git a/src/root/builtin/mod.rs b/src/root/builtin/mod.rs
index 075d995..85566dc 100644
--- a/src/root/builtin/mod.rs
+++ b/src/root/builtin/mod.rs
@@ -1,22 +1,35 @@
-pub mod int;
+pub mod types;
+pub mod functions;
 
-use crate::root::builtin::int::{IntType, register_int};
+use crate::root::builtin::types::int::register_int;
+use crate::root::compiler::global_tracker::GlobalTracker;
 use crate::root::errors::WErr;
 use crate::root::name_resolver::name_resolvers::{GlobalDefinitionTable};
 use crate::root::name_resolver::resolve_function_signatures::FunctionSignature;
-use crate::root::shared::common::{FunctionID, LocalAddress, TypeID};
+use crate::root::shared::common::{ByteSize, FunctionID, LocalAddress, TypeID};
 use crate::root::shared::types::Type;
 
 pub fn register_builtin(global_table: &mut GlobalDefinitionTable) {
     register_int(global_table);
 }
 
-pub type InlineFunctionGenerator = fn(&[LocalAddress], Option<LocalAddress>) -> String;
+pub type InlineFunctionGenerator = fn(&[LocalAddress], Option<LocalAddress>, &mut GlobalTracker, ByteSize) -> String;
+
+const fn f_id(id: u16) -> FunctionID {
+    FunctionID(-(id as isize) - 1)
+}
+
+const fn t_id(id: u16) -> TypeID {
+    TypeID(-(id as isize) - 1)
+}
 
 pub trait BuiltinInlineFunction {
     fn id(&self) -> FunctionID;
     fn name(&self) -> &'static str;
     fn signature(&self) -> FunctionSignature;
     fn inline(&self) -> InlineFunctionGenerator;
+    fn requirements(&self) -> Option<Vec<String>> {
+        None
+    }
     fn parent_type(&self) -> Option<TypeID>;
 }
\ No newline at end of file
diff --git a/src/root/builtin/int/add.rs b/src/root/builtin/types/int/add.rs
similarity index 90%
rename from src/root/builtin/int/add.rs
rename to src/root/builtin/types/int/add.rs
index af8cb79..d9c751e 100644
--- a/src/root/builtin/int/add.rs
+++ b/src/root/builtin/types/int/add.rs
@@ -1,6 +1,6 @@
 use unique_type_id::UniqueTypeId;
-use crate::root::builtin::{BuiltinInlineFunction, InlineFunctionGenerator};
-use crate::root::builtin::int::IntType;
+use crate::root::builtin::{BuiltinInlineFunction, InlineFunctionGenerator, f_id};
+use crate::root::builtin::types::int::IntType;
 use crate::root::errors::WErr;
 use crate::root::name_resolver::name_resolvers::NameResult::Function;
 use crate::root::name_resolver::resolve_function_signatures::FunctionSignature;
@@ -13,7 +13,7 @@ pub struct IntAdd;
 
 impl BuiltinInlineFunction for IntAdd {
     fn id(&self) -> FunctionID {
-        FunctionID(-(IntAdd::unique_type_id().0 as isize) - 1)
+        f_id(IntAdd::unique_type_id().0)
     }
 
     fn name(&self) -> &'static str {
@@ -29,7 +29,7 @@ impl BuiltinInlineFunction for IntAdd {
     }
 
     fn inline(&self) -> InlineFunctionGenerator {
-        |args: &[LocalAddress], return_into: Option<LocalAddress>| -> String {
+        |args: &[LocalAddress], return_into: Option<LocalAddress>, _, _| -> String {
             let lhs = args[0];
             let rhs = args[1];
             let return_into = return_into.unwrap();
diff --git a/src/root/builtin/int/mod.rs b/src/root/builtin/types/int/mod.rs
similarity index 74%
rename from src/root/builtin/int/mod.rs
rename to src/root/builtin/types/int/mod.rs
index bbcbaa3..55a2925 100644
--- a/src/root/builtin/int/mod.rs
+++ b/src/root/builtin/types/int/mod.rs
@@ -1,20 +1,27 @@
 mod add;
 mod sub;
+mod p_sub;
+mod printi;
 
 use b_box::b;
 use unique_type_id::UniqueTypeId;
-use crate::root::builtin::int::add::IntAdd;
-use crate::root::builtin::int::sub::IntSub;
+use crate::root::builtin::t_id;
+use crate::root::builtin::types::int::add::IntAdd;
+use crate::root::builtin::types::int::p_sub::IntPSub;
+use crate::root::builtin::types::int::printi::PrintI;
+use crate::root::builtin::types::int::sub::IntSub;
 use crate::root::errors::WErr;
 use crate::root::name_resolver::name_resolvers::GlobalDefinitionTable;
 use crate::root::parser::parse_function::parse_literal::{LiteralToken, LiteralTokens};
-use crate::root::shared::common::{AddressedTypeRef, ByteSize, FunctionID, LocalAddress, TypeID};
+use crate::root::shared::common::{ByteSize, LocalAddress, TypeID};
 use crate::root::shared::types::Type;
 
 pub fn register_int(global_table: &mut GlobalDefinitionTable) {
     global_table.register_builtin_type(b!(IntType));
     global_table.register_inline_function(&IntAdd);
     global_table.register_inline_function(&IntSub);
+    global_table.register_inline_function(&IntPSub);
+    global_table.register_inline_function(&PrintI);
 }
 
 #[derive(UniqueTypeId)]
@@ -23,7 +30,7 @@ pub struct IntType;
 
 impl IntType {
     pub const fn id() -> TypeID {
-        TypeID(-(IntType::unique_type_id().0 as isize) - 1)
+        t_id(IntType::unique_type_id().0)
     }
 }
 
@@ -53,4 +60,4 @@ impl Type for IntType {
             }
         })
     }
-}
\ No newline at end of file
+}
diff --git a/src/root/builtin/types/int/p_sub.rs b/src/root/builtin/types/int/p_sub.rs
new file mode 100644
index 0000000..ca67c16
--- /dev/null
+++ b/src/root/builtin/types/int/p_sub.rs
@@ -0,0 +1,45 @@
+use unique_type_id::UniqueTypeId;
+use crate::root::builtin::{BuiltinInlineFunction, f_id, InlineFunctionGenerator};
+use crate::root::builtin::types::int::IntType;
+use crate::root::errors::WErr;
+use crate::root::name_resolver::name_resolvers::NameResult::Function;
+use crate::root::name_resolver::resolve_function_signatures::FunctionSignature;
+
+use crate::root::shared::common::{FunctionID, Indirection, LocalAddress, TypeID, TypeRef};
+
+#[derive(UniqueTypeId)]
+#[UniqueTypeIdType = "u16"]
+pub struct IntPSub;
+
+impl BuiltinInlineFunction for IntPSub {
+    fn id(&self) -> FunctionID {
+        f_id(IntPSub::unique_type_id().0)
+    }
+
+    fn name(&self) -> &'static str {
+        "p_sub"
+    }
+
+    fn signature(&self) -> FunctionSignature {
+        FunctionSignature::new_inline_builtin(
+            true,
+            &[("lhs", IntType::id().immediate())],
+            Some(IntType::id().immediate())
+        )
+    }
+
+    fn inline(&self) -> InlineFunctionGenerator {
+        |args: &[LocalAddress], return_into: Option<LocalAddress>, _, _| -> String {
+            let lhs = args[0];
+            let return_into = return_into.unwrap();
+            format!(
+"    mov rax, qword {lhs}
+    neg rax
+    mov qword {return_into}, rax")
+        }
+    }
+
+    fn parent_type(&self) -> Option<TypeID> {
+        Some(IntType::id())
+    }
+}
diff --git a/src/root/builtin/types/int/printi.rs b/src/root/builtin/types/int/printi.rs
new file mode 100644
index 0000000..da2d331
--- /dev/null
+++ b/src/root/builtin/types/int/printi.rs
@@ -0,0 +1,64 @@
+use unique_type_id::UniqueTypeId;
+use crate::root::builtin::{BuiltinInlineFunction, f_id, InlineFunctionGenerator};
+use crate::root::builtin::types::int::IntType;
+use crate::root::errors::WErr;
+use crate::root::name_resolver::name_resolvers::NameResult::Function;
+use crate::root::name_resolver::resolve_function_signatures::FunctionSignature;
+
+use crate::root::shared::common::{FunctionID, Indirection, LocalAddress, TypeID, TypeRef};
+
+#[derive(UniqueTypeId)]
+#[UniqueTypeIdType = "u16"]
+pub struct PrintI;
+
+impl PrintI {
+    pub const fn id() -> FunctionID {
+        f_id(PrintI::unique_type_id().0)
+    }
+}
+
+impl BuiltinInlineFunction for PrintI {
+    fn id(&self) -> FunctionID {
+        Self::id()
+    }
+
+    fn name(&self) -> &'static str {
+        "printi"
+    }
+
+    fn signature(&self) -> FunctionSignature {
+        FunctionSignature::new_inline_builtin(
+            true,
+            &[("lhs", IntType::id().immediate())],
+            None
+        )
+    }
+
+    fn inline(&self) -> InlineFunctionGenerator {
+        |args: &[LocalAddress], _, gt, sz| -> String {
+            let lhs = &args[0];
+
+            let id = format!("{}_fstr", Self::id().string_id());
+
+            let data = format!("{id} db `Integer: %d\\n`,0");
+
+            gt.add_readonly_data(&id, &data);
+
+            let lhs = args[0];
+            format!(
+                "
+    mov rdi, {id}
+    mov rsi, {lhs}
+    mov al, 0
+    sub rsp, {sz}
+    extern printf
+    call printf
+    add rsp, {sz}
+    ")
+        }
+    }
+
+    fn parent_type(&self) -> Option<TypeID> {
+        None
+    }
+}
diff --git a/src/root/builtin/int/sub.rs b/src/root/builtin/types/int/sub.rs
similarity index 90%
rename from src/root/builtin/int/sub.rs
rename to src/root/builtin/types/int/sub.rs
index bb7b367..7cb1da5 100644
--- a/src/root/builtin/int/sub.rs
+++ b/src/root/builtin/types/int/sub.rs
@@ -1,6 +1,6 @@
 use unique_type_id::UniqueTypeId;
-use crate::root::builtin::{BuiltinInlineFunction, InlineFunctionGenerator};
-use crate::root::builtin::int::IntType;
+use crate::root::builtin::{BuiltinInlineFunction, InlineFunctionGenerator, f_id};
+use crate::root::builtin::types::int::IntType;
 use crate::root::errors::WErr;
 use crate::root::name_resolver::name_resolvers::NameResult::Function;
 use crate::root::name_resolver::resolve_function_signatures::FunctionSignature;
@@ -13,7 +13,7 @@ pub struct IntSub;
 
 impl BuiltinInlineFunction for IntSub {
     fn id(&self) -> FunctionID {
-        FunctionID(-(IntSub::unique_type_id().0 as isize) - 1)
+        f_id(IntSub::unique_type_id().0)
     }
 
     fn name(&self) -> &'static str {
@@ -29,7 +29,7 @@ impl BuiltinInlineFunction for IntSub {
     }
 
     fn inline(&self) -> InlineFunctionGenerator {
-        |args: &[LocalAddress], return_into: Option<LocalAddress>| -> String {
+        |args: &[LocalAddress], return_into: Option<LocalAddress>, _, _| -> String {
             let lhs = args[0];
             let rhs = args[1];
             let return_into = return_into.unwrap();
diff --git a/src/root/builtin/types/mod.rs b/src/root/builtin/types/mod.rs
new file mode 100644
index 0000000..8aa5d8f
--- /dev/null
+++ b/src/root/builtin/types/mod.rs
@@ -0,0 +1 @@
+pub mod int;
diff --git a/src/root/compiler/assembly/utils.rs b/src/root/compiler/assembly/utils.rs
index 3d28994..47bb6bc 100644
--- a/src/root/compiler/assembly/utils.rs
+++ b/src/root/compiler/assembly/utils.rs
@@ -1,19 +1,7 @@
 use std::fmt::format;
 use crate::root::shared::common::{ByteSize, FunctionID, LocalAddress};
 
-pub fn get_function_tag(id: FunctionID) -> String {
-    if id.is_main() {
-        return "main".to_string();
-    }
 
-    let id = id.0;
-    if id > 0 {
-        format!("_{id}")
-    }
-    else {
-        format!("__{}", -id)
-    }
-}
 
 pub fn get_jump_tag(id: FunctionID, jump_id: usize) -> String {
     if id.is_main() {
diff --git a/src/root/compiler/compile.rs b/src/root/compiler/compile.rs
index 751ec18..42a077e 100644
--- a/src/root/compiler/compile.rs
+++ b/src/root/compiler/compile.rs
@@ -1,5 +1,6 @@
 use std::collections::{HashMap, HashSet};
 use crate::root::compiler::compile_function::compile_function;
+use crate::root::compiler::global_tracker::GlobalTracker;
 use crate::root::errors::WErr;
 use crate::root::name_resolver::name_resolvers::GlobalDefinitionTable;
 use crate::root::parser::parse_function::FunctionToken;
@@ -9,10 +10,14 @@ pub fn compile(mut global_table: GlobalDefinitionTable, unprocessed_functions: H
     let mut unprocessed_functions = unprocessed_functions;
     let mut compiled_functions = HashMap::new();
     let mut compiled_len = 0usize;
+
     let mut open_set = HashSet::new();
     open_set.insert(FunctionID(0)); // Start with main
+    let mut global_tracker = GlobalTracker::default();
 
     while !open_set.is_empty() {
+        global_tracker.reset_functions();
+
         let current_function = *open_set.iter().next().unwrap();
         open_set.remove(&current_function);
 
@@ -21,13 +26,14 @@ pub fn compile(mut global_table: GlobalDefinitionTable, unprocessed_functions: H
                 continue; // Inline function
             };
 
-        let (compiled, called_functions) = compile_function(current_function, current_function_token, &mut global_table)?;
+        let compiled = compile_function(current_function, current_function_token, &mut global_table, &mut global_tracker)?;
+
         compiled_len += compiled.len() + 10;
         compiled_functions.insert(current_function, compiled);
 
-        for called in called_functions {
-            if !compiled_functions.contains_key(&called) {
-                open_set.insert(called);
+        for called in global_tracker.function_calls() {
+            if !compiled_functions.contains_key(called) {
+                open_set.insert(*called);
             }
         }
     }
@@ -37,7 +43,7 @@ pub fn compile(mut global_table: GlobalDefinitionTable, unprocessed_functions: H
     s +=
 "    global main
 
-    section .text
+section .text
 
 ";
 
@@ -46,5 +52,10 @@ pub fn compile(mut global_table: GlobalDefinitionTable, unprocessed_functions: H
         s += "\n\n";
     }
 
+    if !global_tracker.readonly_data_section().is_empty() {
+        s += "section .data";
+        s += global_tracker.readonly_data_section();
+    }
+
     Ok(s)
 }
\ No newline at end of file
diff --git a/src/root/compiler/compile_evaluable.rs b/src/root/compiler/compile_evaluable.rs
index 17e2847..d19542e 100644
--- a/src/root/compiler/compile_evaluable.rs
+++ b/src/root/compiler/compile_evaluable.rs
@@ -1,8 +1,10 @@
 use std::any::Any;
 use std::collections::HashSet;
-use either::Left;
+use either::{Left, Right};
+use itertools::Itertools;
 use crate::root::compiler::assembly::utils::copy;
 use crate::root::compiler::compile_function_call::call_function;
+use crate::root::compiler::global_tracker::GlobalTracker;
 use crate::root::compiler::local_variable_table::LocalVariableTable;
 use crate::root::errors::evaluable_errors::EvalErrs;
 use crate::root::errors::evaluable_errors::EvalErrs::{OpNoReturn, OpWrongReturnType};
@@ -14,14 +16,18 @@ use crate::root::parser::parse_function::parse_operator::PrefixOrInfixEx;
 use crate::root::shared::common::{FunctionID, Indirection, TypeRef};
 use crate::root::shared::common::AddressedTypeRef;
 
+fn expect_addr(r: (String, Option<AddressedTypeRef>)) -> Result<(String, AddressedTypeRef), WErr> {
+    Ok((r.0, r.1.unwrap())) // TODO
+}
+
 /// Will always evaluate into new address
 pub fn compile_evaluable(
     fid: FunctionID,
     et: &EvaluableToken,
     local_variables: &mut LocalVariableTable,
     global_table: &mut GlobalDefinitionTable,
-    function_calls: &mut HashSet<FunctionID>
-) -> Result<(String, AddressedTypeRef), WErr> {
+    global_tracker: &mut GlobalTracker
+) -> Result<(String, Option<AddressedTypeRef>), WErr> {
 
     let et = et.token();
 
@@ -32,7 +38,7 @@ pub fn compile_evaluable(
                 NameResult::Type(_) => return Err(WErr::n(EvalErrs::CannotEvalStandaloneType(name.name().clone()), name.location().clone())),
                 NameResult::Variable(address) => {
                     let target = global_table.add_local_variable_unnamed_base(address.type_ref().clone(), local_variables);
-                    (copy(*address.local_address(), *target.local_address(), global_table.get_size(target.type_ref())), target)
+                    (copy(*address.local_address(), *target.local_address(), global_table.get_size(target.type_ref())), Some(target))
                 }
             }
         },
@@ -41,16 +47,31 @@ pub fn compile_evaluable(
             let address = global_table.add_local_variable_unnamed_base(TypeRef::new(tid.clone(), Indirection(0)), local_variables);
             let t = global_table.get_type(tid);
 
-            (t.instantiate_from_literal(address.local_address(), literal)?, address)
+            (t.instantiate_from_literal(address.local_address(), literal)?, Some(address))
         }
         EvaluableTokens::InfixOperator(_, _, _) => todo!(),
         EvaluableTokens::PrefixOperator(_, _) => todo!(),
         EvaluableTokens::DynamicAccess(_, _) => todo!(), // Accessed methods must be called
         EvaluableTokens::StaticAccess(_, n) => return Err(WErr::n(NRErrors::CannotFindConstantAttribute(n.name().clone()), n.location().clone())), // Accessed methods must be called
         EvaluableTokens::FunctionCall(inner, args) => {
-            let (slf, fid) = compile_evaluable_function_only(fid, inner, local_variables, global_table, function_calls)?;
-            function_calls.insert(fid);
-            todo!()
+            let (slf, ifid) = compile_evaluable_function_only(fid, inner, local_variables, global_table, global_tracker)?;
+
+            let signature = global_table.get_function_signature(ifid);
+            let return_into = signature.return_type().clone().and_then(|r| Some(global_table.add_local_variable_unnamed_base(r, local_variables)));
+
+            let mut n_args = if let Some(slf) = slf.as_ref() {
+                let mut v = Vec::with_capacity(args.len() + 1);
+                v.push(Right(slf));
+                v
+            }
+            else {
+                Vec::with_capacity(args.len())
+            };
+
+            args.iter().for_each(|a| n_args.push(Left(a)));
+
+            let (code, _) = call_function(fid, ifid, &n_args, return_into.clone(), global_table, local_variables, global_tracker)?;
+            (code, return_into)
         }
     })
 }
@@ -63,7 +84,7 @@ pub fn compile_evaluable_into(
     target: AddressedTypeRef,
     local_variables: &mut LocalVariableTable,
     global_table: &mut GlobalDefinitionTable,
-    function_calls: &mut HashSet<FunctionID>
+    global_tracker: &mut GlobalTracker
 ) -> Result<String, WErr> {
 
     let et = et.token();
@@ -92,7 +113,7 @@ pub fn compile_evaluable_into(
         EvaluableTokens::InfixOperator(lhs, op, rhs) => {
             let mut code = String::new();
 
-            let lhs_type = compile_evaluable_type_only(fid, lhs, local_variables, global_table, function_calls)?;
+            let lhs_type = compile_evaluable_type_only(fid, lhs, local_variables, global_table, global_tracker)?;
             let op_fn = global_table.get_operator_function(*lhs_type.type_id(), op, PrefixOrInfixEx::Infix)?;
             let signature = global_table.get_function_signature(op_fn);
 
@@ -121,7 +142,7 @@ pub fn compile_evaluable_into(
                 }
             }
 
-            let (c, _) = call_function(fid, op_fn, &[Left(lhs), Left(rhs)], Some(target), global_table, local_variables, function_calls)?;
+            let (c, _) = call_function(fid, op_fn, &[Left(lhs), Left(rhs)], Some(target), global_table, local_variables, global_tracker)?;
 
             code += &c;
 
@@ -130,7 +151,7 @@ pub fn compile_evaluable_into(
         EvaluableTokens::PrefixOperator(op, lhs) => {
             let mut code = String::new();
 
-            let lhs_type = compile_evaluable_type_only(fid, lhs, local_variables, global_table, function_calls)?;
+            let lhs_type = compile_evaluable_type_only(fid, lhs, local_variables, global_table, global_tracker)?;
             let op_fn = global_table.get_operator_function(*lhs_type.type_id(), op, PrefixOrInfixEx::Prefix)?;
             let signature = global_table.get_function_signature(op_fn);
 
@@ -159,7 +180,7 @@ pub fn compile_evaluable_into(
                 }
             }
 
-            let (c, _) = call_function(fid, op_fn, &[Left(lhs)], Some(target), global_table, local_variables, function_calls)?;
+            let (c, _) = call_function(fid, op_fn, &[Left(lhs)], Some(target), global_table, local_variables, global_tracker)?;
 
             code += &c;
 
@@ -168,9 +189,21 @@ pub fn compile_evaluable_into(
         EvaluableTokens::DynamicAccess(_, _) => todo!(), // Accessed methods must be called
         EvaluableTokens::StaticAccess(_, n) => return Err(WErr::n(NRErrors::CannotFindConstantAttribute(n.name().clone()), n.location().clone())), // Accessed methods must be called
         EvaluableTokens::FunctionCall(inner, args) => {
-            let (slf, fid) = compile_evaluable_function_only(fid, inner, local_variables, global_table, function_calls)?;
-            function_calls.insert(fid);
-            todo!()
+            let (slf, ifid) = compile_evaluable_function_only(fid, inner, local_variables, global_table, global_tracker)?;
+
+            let mut n_args = if let Some(slf) = slf.as_ref() {
+                let mut v = Vec::with_capacity(args.len() + 1);
+                v.push(Right(slf));
+                v
+            }
+            else {
+                Vec::with_capacity(args.len())
+            };
+
+            args.iter().for_each(|a| n_args.push(Left(a)));
+
+            let (code, _) = call_function(fid, ifid, &n_args, Some(target), global_table, local_variables, global_tracker)?;
+            code
         }
     })
 }
@@ -181,8 +214,8 @@ pub fn compile_evaluable_reference(
     et: &EvaluableToken,
     local_variables: &mut LocalVariableTable,
     global_table: &mut GlobalDefinitionTable,
-    function_calls: &mut HashSet<FunctionID>
-) -> Result<(String, AddressedTypeRef), WErr> {
+    global_tracker: &mut GlobalTracker
+) -> Result<(String, Option<AddressedTypeRef>), WErr> {
 
     let ets = et.token();
 
@@ -192,31 +225,38 @@ pub fn compile_evaluable_reference(
                 NameResult::Function(_) => return Err(WErr::n(EvalErrs::FunctionMustBeCalled(name.name().clone()), name.location().clone())),
                 NameResult::Type(_) => return Err(WErr::n(EvalErrs::CannotEvalStandaloneType(name.name().clone()), name.location().clone())),
                 NameResult::Variable(address) => {
-                    ("".to_string(), address)
+                    ("".to_string(), Some(address))
                 }
             }
         },
-        EvaluableTokens::Literal(_) => compile_evaluable(fid, et, local_variables, global_table, function_calls)?,
-        EvaluableTokens::InfixOperator(_, _, _) => compile_evaluable(fid, et, local_variables, global_table, function_calls)?,
-        EvaluableTokens::PrefixOperator(_, _) => compile_evaluable(fid, et, local_variables, global_table, function_calls)?,
+        EvaluableTokens::Literal(_) => compile_evaluable(fid, et, local_variables, global_table, global_tracker)?,
+        EvaluableTokens::InfixOperator(_, _, _) => compile_evaluable(fid, et, local_variables, global_table, global_tracker)?,
+        EvaluableTokens::PrefixOperator(_, _) => compile_evaluable(fid, et, local_variables, global_table, global_tracker)?,
         EvaluableTokens::DynamicAccess(_, _) => todo!(), // Accessed methods must be called
         EvaluableTokens::StaticAccess(_, n) => return Err(WErr::n(NRErrors::CannotFindConstantAttribute(n.name().clone()), n.location().clone())), // Accessed methods must be called
-        EvaluableTokens::FunctionCall(_, _) => compile_evaluable(fid, et, local_variables, global_table, function_calls)?
+        EvaluableTokens::FunctionCall(_, _) => compile_evaluable(fid, et, local_variables, global_table, global_tracker)?,
     })
 }
 
 /// Will always return a function pointer (and self)
 pub fn compile_evaluable_function_only(
     fid: FunctionID,
-    et: &EvaluableToken,
+    name: &EvaluableToken,
     local_variables: &mut LocalVariableTable,
     global_table: &mut GlobalDefinitionTable,
-    function_calls: &mut HashSet<FunctionID>
+    global_tracker: &mut GlobalTracker
 ) -> Result<(Option<AddressedTypeRef>, FunctionID), WErr> {
-
-    let et = et.token();
-
-    todo!()
+    Ok(match name.token() {
+        EvaluableTokens::Name(name, containing_class) => {
+            match global_table.resolve_name(name, containing_class.as_ref(), local_variables)? {
+                NameResult::Function(fid) => {
+                    (None, fid)
+                }
+                _ => todo!(),
+            }
+        }
+        _ => todo!()
+    })
 }
 
 /// Will ignore everything other than type
@@ -225,7 +265,7 @@ pub fn compile_evaluable_type_only(
     et: &EvaluableToken,
     local_variables: &mut LocalVariableTable,
     global_table: &mut GlobalDefinitionTable,
-    function_calls: &mut HashSet<FunctionID>
+    global_tracker: &mut GlobalTracker
 ) -> Result<TypeRef, WErr> {
 
     let et = et.token();
@@ -249,8 +289,8 @@ pub fn compile_evaluable_type_only(
             //     return Err(WErr::n(EvalErrs::FoundPrefixNotInfixOp(op.operator().to_str().to_string()), op.location().clone()));
             // }
 
-            // let (mut code, lhs) = compile_evaluable(fid, lhs, local_variables, global_table, function_calls)?;
-            let lhs_type = compile_evaluable_type_only(fid, lhs, local_variables, global_table, function_calls)?;
+            // let (mut code, lhs) = compile_evaluable(fid, lhs, local_variables, global_table, global_tracker)?;
+            let lhs_type = compile_evaluable_type_only(fid, lhs, local_variables, global_table, global_tracker)?;
             // code += "\n";
             let op_fn = global_table.get_operator_function(*lhs_type.type_id(), op, PrefixOrInfixEx::Infix)?;
             let signature = global_table.get_function_signature(op_fn);
@@ -260,7 +300,11 @@ pub fn compile_evaluable_type_only(
         EvaluableTokens::DynamicAccess(_, _) => todo!(), // Accessed methods must be called
         EvaluableTokens::StaticAccess(_, n) => return Err(WErr::n(NRErrors::CannotFindConstantAttribute(n.name().clone()), n.location().clone())), // Accessed methods must be called
         EvaluableTokens::FunctionCall(inner, args) => {
-            todo!()
+            let (slf, ifid) = compile_evaluable_function_only(fid, inner, local_variables, global_table, global_tracker)?;
+
+            let signature = global_table.get_function_signature(ifid);
+            let return_type = signature.return_type().clone().unwrap(); // TODO: Check type
+            return_type
         }
     })
 }
@@ -272,7 +316,7 @@ pub fn compile_evaluable_type_only_into(
     target: TypeRef,
     local_variables: &mut LocalVariableTable,
     global_table: &mut GlobalDefinitionTable,
-    function_calls: &mut HashSet<FunctionID>
+    global_tracker: &mut GlobalTracker
 ) -> Result<bool, WErr> {
 
     let et = et.token();
diff --git a/src/root/compiler/compile_function.rs b/src/root/compiler/compile_function.rs
index 5d78c47..2e20c96 100644
--- a/src/root/compiler/compile_function.rs
+++ b/src/root/compiler/compile_function.rs
@@ -1,7 +1,8 @@
 use std::collections::HashSet;
-use crate::root::builtin::int::IntType;
-use crate::root::compiler::assembly::utils::{align_16_bytes, align_16_bytes_plus_8, get_function_tag};
+use crate::root::builtin::types::int::IntType;
+use crate::root::compiler::assembly::utils::{align_16_bytes, align_16_bytes_plus_8};
 use crate::root::compiler::compile_evaluable::{compile_evaluable, compile_evaluable_into, compile_evaluable_reference};
+use crate::root::compiler::global_tracker::GlobalTracker;
 use crate::root::compiler::local_variable_table::LocalVariableTable;
 use crate::root::errors::WErr;
 use crate::root::name_resolver::name_resolvers::{GlobalDefinitionTable};
@@ -10,7 +11,7 @@ use crate::root::parser::parse_function::parse_line::LineTokens;
 use crate::root::shared::common::{FunctionID, Indirection, LocalAddress, TypeRef};
 use crate::root::shared::common::AddressedTypeRef;
 
-pub fn compile_function(fid: FunctionID, function: FunctionToken, global_table: &mut GlobalDefinitionTable) -> Result<(String, HashSet<FunctionID>), WErr> {
+pub fn compile_function(fid: FunctionID, function: FunctionToken, global_table: &mut GlobalDefinitionTable, global_tracker: &mut GlobalTracker) -> Result<String, WErr> {
     let mut local_variables = LocalVariableTable::new();
 
     let (_location, _name, return_type, _, parameters, lines) = function.dissolve();
@@ -41,8 +42,7 @@ pub fn compile_function(fid: FunctionID, function: FunctionToken, global_table:
         ))
     );
 
-    let mut function_calls = HashSet::new();
-    let full_contents = recursively_compile_lines(fid, &lines, &return_variable, &mut local_variables, global_table, &mut function_calls)?;
+    let full_contents = recursively_compile_lines(fid, &lines, &return_variable, &mut local_variables, global_table, global_tracker)?;
 
     // let stack_size = local_variables.stack_size();
 
@@ -52,7 +52,7 @@ pub fn compile_function(fid: FunctionID, function: FunctionToken, global_table:
     push rbp
     mov rbp, rsp
     {}",
-        get_function_tag(fid),
+        fid.string_id(),
         full_contents
     );
 
@@ -60,10 +60,13 @@ pub fn compile_function(fid: FunctionID, function: FunctionToken, global_table:
         final_contents += "\n\tleave\n\tret"
     }
 
-    Ok((final_contents, function_calls))
+    Ok(final_contents)
 }
 
-fn recursively_compile_lines(fid: FunctionID, lines: &[LineTokens], return_variable: &Option<AddressedTypeRef>, local_variables: &mut LocalVariableTable, global_table: &mut GlobalDefinitionTable, function_calls: &mut HashSet<FunctionID>) -> Result<String, WErr> {
+fn recursively_compile_lines(fid: FunctionID, lines: &[LineTokens], return_variable: &Option<AddressedTypeRef>, local_variables: &mut LocalVariableTable, global_table: &mut GlobalDefinitionTable, global_tracker: &mut GlobalTracker) -> Result<String, WErr> {
+    for i in lines {
+        println!("{:#?}", i);
+    }
     local_variables.enter_block();
     let mut contents = String::new();
 
@@ -76,7 +79,7 @@ fn recursively_compile_lines(fid: FunctionID, lines: &[LineTokens], return_varia
                 let (name, type_name, value) = (it.name(), it.type_name(), it.value());
                 let address = global_table.add_local_variable_named(name.name().clone(), type_name, local_variables)?;
                 contents += "\n";
-                contents += &compile_evaluable_into(fid, value, address, local_variables, global_table, function_calls)?;
+                contents += &compile_evaluable_into(fid, value, address, local_variables, global_table, global_tracker)?;
             },
             LineTokens::Assignment(_) => todo!(),
             LineTokens::If(_) => todo!(),
@@ -89,7 +92,7 @@ fn recursively_compile_lines(fid: FunctionID, lines: &[LineTokens], return_varia
                     }
 
                     let address = global_table.add_local_variable_unnamed_base(TypeRef::new(IntType::id(), Indirection(0)), local_variables);
-                    let code = compile_evaluable_into(fid, rt.return_value().as_ref().unwrap(), address.clone(), local_variables, global_table, function_calls)?;
+                    let code = compile_evaluable_into(fid, rt.return_value().as_ref().unwrap(), address.clone(), local_variables, global_table, global_tracker)?;
                     contents += "\n";
                     contents += &code;
                     contents += &format!("\n\tmov rax, qword {}", address.local_address());
@@ -100,7 +103,7 @@ fn recursively_compile_lines(fid: FunctionID, lines: &[LineTokens], return_varia
                             todo!()
                         }
 
-                        let code = compile_evaluable_into(fid, return_value, return_variable.clone().unwrap(), local_variables, global_table, function_calls)?;
+                        let code = compile_evaluable_into(fid, return_value, return_variable.clone().unwrap(), local_variables, global_table, global_tracker)?;
                         contents += "\n";
                         contents += &code;
                     }
@@ -117,7 +120,7 @@ fn recursively_compile_lines(fid: FunctionID, lines: &[LineTokens], return_varia
             LineTokens::Break(_) => todo!(),
             LineTokens::NoOp(et) => {
                 contents += "\n";
-                contents += &compile_evaluable_reference(fid, et, local_variables, global_table, function_calls)?.0;
+                contents += &compile_evaluable_reference(fid, et, local_variables, global_table, global_tracker)?.0;
             }
         }
     }
diff --git a/src/root/compiler/compile_function_call.rs b/src/root/compiler/compile_function_call.rs
index 3ad8278..56f2180 100644
--- a/src/root/compiler/compile_function_call.rs
+++ b/src/root/compiler/compile_function_call.rs
@@ -1,8 +1,9 @@
 use std::collections::HashSet;
 use either::Either;
 use itertools::Itertools;
-use crate::root::compiler::assembly::utils::{align_16_bytes, align_16_bytes_plus_8, copy, get_function_tag};
+use crate::root::compiler::assembly::utils::{align_16_bytes, align_16_bytes_plus_8, copy};
 use crate::root::compiler::compile_evaluable::{compile_evaluable, compile_evaluable_into};
+use crate::root::compiler::global_tracker::GlobalTracker;
 use crate::root::compiler::local_variable_table::LocalVariableTable;
 use crate::root::errors::WErr;
 use crate::root::name_resolver::name_resolvers::GlobalDefinitionTable;
@@ -19,12 +20,14 @@ pub fn call_function(
     return_address: Option<AddressedTypeRef>,
     global_table: &mut GlobalDefinitionTable,
     local_variables: &mut LocalVariableTable,
-    function_calls: &mut HashSet<FunctionID>) -> Result<(String, Option<AddressedTypeRef>), WErr> {
-    function_calls.insert(fid);
+    global_tracker: &mut GlobalTracker) -> Result<(String, Option<AddressedTypeRef>), WErr> {
+    global_tracker.f_call(fid);
 
     warn("Unchecked Function Arguments");
 
     if let Some(inline) = global_table.get_function(fid).1 {
+
+
         let inline_o = inline.clone();
         let mut code = String::new();
 
@@ -55,7 +58,7 @@ pub fn call_function(
             match a {
                 Either::Left(eval) => {
                     let into = global_table.add_local_variable_unnamed_base(signature_args[i].clone(), local_variables);
-                    let c = compile_evaluable_into(parent_fid, eval, into.clone(), local_variables, global_table, function_calls)?;
+                    let c = compile_evaluable_into(parent_fid, eval, into.clone(), local_variables, global_table, global_tracker)?;
 
                     if i != 0 {
                         code += "\n";
@@ -72,7 +75,7 @@ pub fn call_function(
         }
 
         code += "\n";
-        code += &inline_o(&args, return_into.as_ref().map(|x| *x.local_address()));
+        code += &inline_o(&args, return_into.as_ref().map(|x| *x.local_address()), global_tracker, local_variables.stack_size());
         Ok((code, return_into))
     }
     else {
@@ -88,7 +91,7 @@ pub fn call_function(
                 Either::Left(eval) => {
                     let into = global_table.add_local_variable_unnamed_base(signature_args[i].clone(), local_variables);
                     size += global_table.get_size(into.type_ref());
-                    let c = compile_evaluable_into(parent_fid, eval, into.clone(), local_variables, global_table, function_calls)?;
+                    let c = compile_evaluable_into(parent_fid, eval, into.clone(), local_variables, global_table, global_tracker)?;
                     if i != 0 {
                         code += "\n";
                     }
@@ -133,7 +136,7 @@ pub fn call_function(
         }
 
         code += &format!("\n    sub rsp, {}", local_variables.stack_size().0);
-        code += &format!("\n    call {}", get_function_tag(fid));
+        code += &format!("\n    call {}", fid.string_id());
         code += &format!("\n    add rsp, {}", local_variables.stack_size().0);
 
         // ? Leave block (invalidate parameters)
diff --git a/src/root/compiler/global_tracker.rs b/src/root/compiler/global_tracker.rs
new file mode 100644
index 0000000..898c076
--- /dev/null
+++ b/src/root/compiler/global_tracker.rs
@@ -0,0 +1,32 @@
+use std::collections::HashSet;
+use derive_getters::{Dissolve, Getters};
+use crate::root::shared::common::FunctionID;
+
+#[derive(Default, Dissolve, Getters)]
+pub struct GlobalTracker {
+    function_calls: HashSet<FunctionID>,
+    readonly_contents: HashSet<String>,
+    readonly_data_section: String
+}
+
+impl GlobalTracker {
+    pub fn functions_mut(&mut self) -> &mut HashSet<FunctionID> {
+        &mut self.function_calls
+    }
+
+    pub fn f_call(&mut self, fid: FunctionID) {
+        self.function_calls.insert(fid);
+    }
+
+    pub fn reset_functions(&mut self) {
+        self.function_calls = Default::default();
+    }
+
+    pub fn add_readonly_data(&mut self, name: &str, data: &str) {
+        if !self.readonly_contents.contains(name) {
+            self.readonly_contents.insert(name.to_string());
+            self.readonly_data_section += "\n    ";
+            self.readonly_data_section += data;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src/root/compiler/mod.rs b/src/root/compiler/mod.rs
index f56240c..29e11a6 100644
--- a/src/root/compiler/mod.rs
+++ b/src/root/compiler/mod.rs
@@ -3,4 +3,5 @@ pub mod local_variable_table;
 mod compile_function;
 pub mod assembly;
 mod compile_evaluable;
-pub mod compile_function_call;
\ No newline at end of file
+pub mod compile_function_call;
+pub mod global_tracker;
\ No newline at end of file
diff --git a/src/root/parser/parse_function/parse_literal.rs b/src/root/parser/parse_function/parse_literal.rs
index cdbb843..a50665b 100644
--- a/src/root/parser/parse_function/parse_literal.rs
+++ b/src/root/parser/parse_function/parse_literal.rs
@@ -2,7 +2,7 @@ use derive_getters::{Dissolve, Getters};
 use crate::root::parser::parse::{Location, ParseResult, Span};
 use nom::branch::alt;
 use nom::bytes::complete::tag;
-use crate::root::builtin::int::IntType;
+use crate::root::builtin::types::int::IntType;
 use crate::root::parser::parse_util::discard_ignored;
 use crate::root::shared::common::{Indirection, TypeID, TypeRef};
 use crate::root::shared::types::Type;
diff --git a/src/root/shared/common.rs b/src/root/shared/common.rs
index 8bb271e..9ead72f 100644
--- a/src/root/shared/common.rs
+++ b/src/root/shared/common.rs
@@ -24,6 +24,20 @@ impl FunctionID {
     pub fn is_main(&self) -> bool {
         self.0 == 0
     }
+
+    pub fn string_id(&self) -> String {
+        if self.is_main() {
+            return "main".to_string();
+        }
+
+        let id = self.0;
+        if id > 0 {
+            format!("_{id}")
+        }
+        else {
+            format!("__{}", -id)
+        }
+    }
 }
 
 #[derive(Debug, PartialEq, Eq, Hash, Display, Copy, Clone)]
diff --git a/types.toml b/types.toml
index bbec0b9..38b4c7c 100644
--- a/types.toml
+++ b/types.toml
@@ -1,3 +1,10 @@
 IntType=0
 IntAdd=1
 IntSub=2
+IntPSub=3
+P=4
+Pr=5
+Pri=6
+Prin=7
+Print=8
+PrintI=9