►
From YouTube: OMR Architecture Meeting 20230831
Description
Agenda:
* JitBuilder 2 Extension object code walk through [ @mstoodle ]
A
B
A
C
B
C
B
C
B
C
Unless
I
need
to
open
another
file,
it
might
be
okay,
all
right.
So
all
right.
So
the
last
two
meetings
I
basically
assembled
a
bunch
of
slides
and
included
some
code
snippets
on
slides
but
really
didn't
and
and
tried
to
kind
of,
take
you
through
and
give
you
a
flavor
for
how
some
of
the
things
were
put
together,
but
it
struck
me
afterwards
or
actually
during
some
of
the
questions.
C
So
if
you
remember
extensions
are
basically
like
plugable
capability,
you
can
plug
that
capability
into
the
compiler,
so
the
compiler,
the
base
compiler,
doesn't
have
any
notion
of
things
other
than
the
base
types
that
it
defines
itself
and
extensions
can
come
along
and
add
new
types.
New
symbols:
new
operation,
types,
new,
compiler,
return,
codes,
Etc.
So
let's
take
a
look
at
how
some
of
that
works.
C
So
this
is
the
header
file
for
for
the
base
extension
and
for
now,
I've
kind
of
provided
some
convenience
header
files
that
allow
you
to
not
have
to
go
and
figure
out
what
all
things
you
exactly
refer
to,
which
obviously
has
a
compile
time
impact.
But
it's
much
simpler
to
figure
out
which
header
files
to
include
so
there's
a
JV
core.hp,
which
is
basically
the
collection
of
all
the
header
files
in
the
core,
jit
Builder,
2
or
jv2
project.
C
C
When
you
create
these
libraries,
but
that's
a
that's
a
minor
thing
and
then
the
sort
of
note,
the
the
a
common
way
that
I've
been
implementing
different
extensions
is
to
give
them
all
their
own
namespace
sub
name
space
inside
there.
So
the
base
extension
has
a
namespace
called
base,
and
so
all
of
the
stuff,
that's
in
the
base.
Extension
goes
into
the
base
namespace
and
isn't
isn't
supposed
to
pollute.
C
So
you
can
kind
of
forecast
some
of
the
things
that
you're
going
to
see
in
this
in
this
base.
Extension,
there's
all
the
Primitive
types
that
used
to
exist
in
jet,
Builder
and
standard
things
there's
the
case
guy,
which
is
used
that
creates
switch
operations,
there's
pointer
types,
there's
types
associated
with
structs
that
have
Fields
Union
type,
although
I
don't
actually
use
this
yet
Union
types
actually
kind
of
redundant
in
building
jb2
for
Stark
type
and
then
switch
Builders
kind
of
interesting
thing.
Yeah.
C
Let
me
see
are
these
all
here,
because
this
file
uses
this
file
references
these
types?
Yes,
okay,
it
references
them;
it
doesn't
require
the
actual
definitions
for
them
all
right,
and
so
we
finally
get
to
the
actual
base
extension
class,
which
is
an
extension
of
a
thing
called
subclasses.
A
thing
called
extension,
which
is
where
all
the
core
functionality
for
building
extensions
exists.
C
So
this
base
extension
object.
Remember
is
an
object,
a
Singleton
object
for
the
plug-in
that
basically
represents
all
the
capability
in
the
plugin
in
in
essence.
So
you,
whenever
you
want
to
use
something
from
the
plugin,
you
end
up
calling
something
or
referencing
something
off
of
the
base
extension
object,
and
that
means
you
can
pass
around
this
base
extension
object
to
people,
and
then
they
can
use
the
capabilities
in
that
plug-in
very
easily.
C
So
one
of
the
things
that
it
depends
on
is
the
core
extension,
which
is
a
sort
of
it's
defined
by
jb2
I'm,
not
going
to
go
into
details
on
that.
It's
some
very
it's
a
very
simple
extension,
so
I'm
not
going
to
bother
looking
at
it.
We
looked
at
some
of
the
allocator
stuff
and
how
you
introduce
that
into
the
class.
You
can
see
the
JB
Outlook
thing
here
and
the
dynamic
Outlook
only
helper
to
create
the
Constructor
that
automatically
takes
an
allocator
object,
so
you
don't
have
to
think
about
it.
C
Etc
in
this.
In
this
instructor
it
has
a
name
which
is
the
name
of
the
the
actual
extension
it
has
a
semantic
version
associated
with
it.
So
you
can.
There
is
a
way
of
saying
I
depend
on
a
certain
version
of
this
extension,
and
it
can
distinguish
between
you
know,
minor
and
Patch,
updates
to
the
extension
that
still
support
the
same
API
versus
major
version
updates,
which
which
would
break
the
API
potentially.
B
C
Oh
string
yeah,
that's
my
string!
Okay,
yeah,
sorry
yeah!
That's
my
string!
Okay,
which
I'm
actually
in
the
process
of
ripping
standard
string
out
of
makes
it
Darren
for
debit.
Three
for
pointing
out
that
I
needed
to
do
that
anyway,
or
the
pain
that
I
would
have.
When
I
tried
to
do
that,
right,
okay
and
then,
as
I
mentioned
there
are.
This
object,
has
various
things
kind
of
hanging
off
them.
So,
for
example,
the
Primitive
types
end
up
becoming
fields
of
this
base.
C
Extension
object,
so
there's
a
no
type
guy,
which
is
actually
from
the
core
extension.
But
we
cache
it
here
just
so
that
it's
easy
to
get
at.
It's
kind
of
like
the
void
type,
an
8-bit
integer,
16-bit,
integer,
32,
64-bit,
integer,
I,
renamed,
jit,
Builders
float
and
double
to
float.
32
and
Float.
64
is
for
consistency
with
the
integer
ones.
C
C
Basically,
if
you
ask
an
operation
what
its
action
is,
it
will
return
you,
this
action
ID
in
different
extensions,
because
they
add
new
operation
types
need
to
have
this
action
ID
that
differentiates
between
the
operations
that
it
that
dot
extension
can
create
so
that
you
can
always
identify
which
ones.
What
a
particular
operation
is
in
essence.
C
C
So
that's
the
full
set
of
actions
that
the
base
extension
currently
defines.
So
it's
not
obviously
equivalent
to
the
full
set
of
operations
that
jit
Builder
used
to
support.
But
the
intention
is
that
most
of
those
operations
will
probably
show
up
here
eventually-
and
there
are
some
new
ones
compared
to
Jet
Builder,
so
I
didn't
used
to
have
a
thing
called
load
field
and
store
field.
C
Another
thing
that
you
need
to
be
able
to
add
are
our
return
codes
as
things
go
wrong
or
error
conditions
that
this
that
this
extension
can
detect
and
and
report.
So
there's
a
way
of
registering
with
the
compiler
to
say:
hey,
I
need
a
return
code
for
this
condition
and
then
that
condition
gets
stored
on
the
base
extension
object.
So
you
can
go
and
say
was
the
return
code,
this
right
so
very
easy
way
to
do
that
and
then
finally
I
think.
Finally
there's
a
section
of
operation,
so
these
are
functions.
C
Member
functions
on
the
extension
object
that
allow
you
to
create
operations
of
those
same
types
that
we
had
the
action
IDs
for
before
right.
So
you
can
create
a
constant
app
in
this
builder
at
this
I.
Don't
know
why
I
didn't
put
a
b
there
and
a
constant
which
uses
this
literal
or
you
can
add
and
put
an
ad
operation
in
this
Builder
and
add
these
two
values
together
and
it
will
return
the
the
result
of
the
ad
and
Etc.
All
of
them
are
annotated
by
location.
C
So
you
can,
you
know
again
if
something
goes
wrong
or
if
the
wrong
operand
or
our
brand
types
are
provided
to
the
operation
Creator
it
can
it.
Then
it
detects
that
there's
a
problem.
It
can
record
the
location
that
you
called
this
thing
from,
so
you
can
find
the
the
whoever
it
was
that
supplied
the
wrong
thing.
Basically,
in
terms
of
control
operations,
you
know,
most
of
them
are
fairly
like
the
the
simple
ones
are
fairly.
C
You
know
easy
to
kind
of
understand
how
they
work
all
of
these
all
of
these
functions.
Sorry,
it
keeps
showing
me
all
the
details
about
things
all
of
these
have
as
their
first
operation
the
Builder
into
which
the
operation
is
supposed
to
be
inserted.
So
in
jit
Builder
you
used
to
do
B
Arrow
go
to
B
Arrow.
C
Yeah,
so
the
so.
The
reason
why
there's
two
is
because
this
so
so
for
go
to,
for
example,
B
is
the
is
the
is
the
Builder
object
in
which
the
go-to
operation
should
be
created,
and
then
Target
is
the
one
that
it
should
it's
intending
to
direct
control
flow
to
right.
So
it's
actually
inserting
a
go-to
instruction
into
Builder
B
that
says
go
to
Target.
D
C
C
D
D
And
if
you
agreed
with
me,
that
block
is
a
you
know
as
a
name
that
we
would
might
all
understand.
You
know
given
some
C
or
C,
plus
plus
background
or
even
Java
right,
and
so
the
block
is
the
thing
that
that
we're
growing
and
the
Builder
is
the
toolbox
that
we're
using
to
make
it
happen,
and
so,
like
I,
say,
I
might
expect
the
go-to
to
take
a
builder.
You
know
that's
where
the
tools
come
from
and
a
block,
that's
where
we
want
the
results
to
go
and
so
I
I'm.
C
I
I
mean
I,
understand,
I,
understand
what
you're
saying
I
guess
this
is
the
so
so
one
of
the
thing
this
is
something
that
we
inherited
from
the
jit
Builder
API.
So
it's
it's
a
long-standing
mistake,
if
you
want
to
in
in
the
API
for
jit
Builder
and
then
and
then
a
a
sequence
of
operations
and
the
label
to
the
operations
like
the
the
thing
that
you
use
to
build.
The
list,
as
well
as
the
thing
that
you
are
are
having
instructions
Branch
to
is
the
same
is
called
the
same
thing.
D
D
D
C
Application,
it
is
a
full.
It
is
representing
a
full
like
code
path.
Like
a
region
of
code,
you
write
a
block,
I
mean
it's
it's,
it
is
a
block
of
code,
but
it's
I
guess
we
share
the
same
concept
to
simplify
the
number
of
different
things.
We've
got,
but
I
can
get
that.
That
might
be
confusing
the
first
time
you
see
it
yeah.
C
Yeah
sure
so
one
of
one
of
the
things
that
did
change
between
jit
Builder
and
jb2
to
Builder,
2
I
guess
is.
Are
things
like
how,
if
then
else
and
for
Loop
operations
work?
So
it
used
to
be
the
case
that
you
would
pass
in
you
could
create
or
not
it
would
create
automatically
for
you,
Builder
objects
that
would
represent
the
body
of
the
for
Loop
or
the.
C
C
The
the
creation
of
those
Builders,
because
in
in
jb2
they're
they're
called
bound
Builders
they're
actually
created
by
the
for
Loop
itself,
so
you
can't
pass
them
in
yourself
anymore,
and
the
way
that
you
find
those
things
is
bought
is
through
this
for
Loop
Builder
object
that
gets
passed
by
and
notice.
This
isn't
a
pointer,
it's
just
passing
back
a
whole
thing
by
copy
and
essentially
for
Loop
Builder
just
has
it
basically
records
all
the
information
about
the
for
Loop
that
you
might
need
to
know,
so
it
has
the
loop
variable
in
it.
C
It
has
the
initial
final
and
bump
in
it.
It
has
the
bodybuilder.
It
has
the
brake
Builder
the
continue
Builder
Etc.
So
as
you're
working
through
this
as
you're
building
up
the
code
inside
the
for
Loop,
you
can
just
access
this
The
Returned
for
Loop
folder,
to
figure
out
where
to
put
things
and
how
to
get
to
the
to
the
various
bits
and
pieces
of
the
for
Loop.
That's
that's
going
to
be
constructed
and
the
same
thing
for
if
then
else,
so
you
don't
pass
in
any
more
then
path
or
an
out
path.
C
C
Etc
switch
has
a
flip
side,
so
I
don't
know
I'm,
not
perfectly
happy
with
this
notation
or
nomenclature.
I.
Guess
that
I've
chosen
that
you
in
some
cases
you
get
a
builder
object
back
and
in
some
cases
you
pass
a
builder
object
in
so
for
switch.
You
pass
in
a
switch
Builder
because
in
the
case
of
a
switch
you
kind
of
have
to
be
able
to
get
all
of
the
case
things
you
have
to
kind
of
build
them
as
you
go
and
pass
them
in.
C
D
C
C
One
thing
that's
so,
and
and
the
they
sort
of
have
a
way
of
checking
their
own
semantics
like,
for
example,
all
of
these
operations,
including
the
the
arithmetic
operations,
basically
assume
in
most
cases,
it's
not
completely
true,
but
bear
with
me
that,
like
the
left
and
right
values
all
have
the
same
type
like
exactly
the
same
type.
So
one
of
the
things
that
gets
validated
and
at
least
some
of
these
operations
right
now
is
that
left
type.
C
It
can
there's
a
mechanism
whereby
it
can
add
its
own
kind
of
operation,
Checker
in
in
there
to
say
if
left
type
equals
right
type
and
the
type
that
type
is
complex,
that's,
okay
and
and
if
there
are
and
if
and
and
it
will
still
and
the
other
any
other
combination
of
types
won't
be
well.
The
validation
of
types
will
otherwise
be
unchanged.
D
C
Not
sure
I
understand
the
example
that
you're
actually
that
you're
referencing
in
in
your
thing,
but
like
in
principle,
you
could
create
your
own
extension,
which
would
Define
what
that
control
construct
is,
and
you
could
build
that
control
construct
out
of
the
operations
that
are
in
this
extension.
If
you
wanted
to.
D
C
Yep,
okay,
yeah
so
I
mean
that's
I
mean
essentially
this
base
extension.
It's
not
part
of
the
core
gb2
functionality
right,
like
the
this
whole
base.
Extension
is
completely
optional.
You
don't
have
to
load
it
into
your
compiler
or
not
so
the
core
function.
The
core
compiler,
has
no
idea
of
almost
any
operation
at
all.
So
all
of
this
is
the
base
extension
adding
in
support
for
creating
and
manipulating
these
kinds
of
operations
that
it
knows
about.
B
C
There
are,
then,
some
pseudo
operations,
so
these
are
kind
of
like
you're
thinking
like
helpers
they're.
Not
they
don't
actually
create
operations
called
constant,
eight
constant
16,
constant
32,
but
what
they
do
is
they
take
a
different
set
of
parameters
and
construct
some
IL.
That
is
so
that
our
IR
that's
associated
with
it.
So
in
the
case
of
these
constant
ones,
what
all
of
these
yeah?
What
all
these
things
do?
C
Is
they
automatically
create
a
literal
object
of
the
appropriate
type,
and
then
they
call
back
into
cons
to
create
a
const
operation
that
takes
that
literal.
So
it's
like
a
helper.
Basically
it's
a
so
you
don't
have
to
always
create
the
literal
object
yourself.
You
can
just
if
you
have
a
if
you
have
a
bite
or
us
or
a
you
know
a
32-bit
value
in
your
hands.
C
You
can
use
one
of
these
to
just
create
it
directly
without
having
to
you
know,
create
sort
of
some
of
the
all
the
intermediate
stuff
on
intermediate
stuff,
but
anyway
I
think
you
know
what
I
mean,
and
basically
it
has
one
of
these
for
all
of
the
sort
of
Base
primitive
types,
there's
a
way
of
creating
a
zero
and
a
one
for
types,
not
all
types
support
the
creation
of
a
zero
and
one.
So
it's
possible
that
this
will
fail.
C
Some
of
these
came
about,
because
when
you
look
at
some
of
the
jit
Builder
samples,
there's
like
it's
repeatedly,
it's
like
I
need
a
constant
one.
I
need
a
constant
one.
I
need
a
constant
zero
I
need
a
blah
blah
blah,
so
these
ones
just
make
it
a
little
bit
simpler
to
create
those
kinds
of
things
and
then
some
of
the
other
helpers
here
around
you
know
if
you
need
to
do
access
an
array,
for
example,
it
kind
of
folds
together
a
couple
of
the
constituent
operations.
C
It
combines
a
load
at
with
an
index
at
operation,
and
you
you
don't
have
to
provide
as
many
things
you
don't
have
to
hold
on
to
the
intermediate
value
yourself
Etc.
So
it's
a
little
bit
of
convenience
for
some
of
the
common
uses
for
some
of
the
the
pointer
manipulation
stuff
and
then
that
functionality
that
I
I
mentioned
before
for
being
able
to
add
handling
of
different
kinds
of
types
is
done
right.
C
Now,
it's
done
with
a
thing
called
a
base,
extension
Checker,
which
is
a
class
that
just
kind
of
knows
how
to
validate
operations
of
this
type.
This
is
a
pretty
ugly
hack
right
now.
I,
don't
like
this
I'm
gonna
rewrite
this
at
some
point:
to
use
the
add-on
infrastructure
that
I
mentioned
in
the
in
the
previous
talk.
But
right
now
it's
it's
built
on
this
base.
C
C
This
is
how
the
extensibility,
for
so
basic
extension,
is
an
extensible
type.
So
this
is
what
helps
to
register
the
base
extension
is
in
into
that
extensibility
mechanism.
It
has
base
extension
check
base
extension.
Checker
is
pretty
bogus.
Looking
I'll
show
an
example
of
how
this
how
this
gets
called
when
you,
when
you're,
creating
this.
Basically
those
functions
that
I
showed
before
that
create
operations.
They
will
call
into
validate
ad
on
a
checker
object.
C
It
goes
looking
for
any
Checker
objects
that
are
around
and
it
will
call
validate,
add
and
if
somebody
validates
it
and
says
yes,
it's
valid,
then
that's
great.
If
somebody
validates
and
says
it's
it's
bad,
then
it
then
it
automatically
calls
a
fail
validate
and
which
will
create
an
exceptional
object
and
throw
it
and
and
and
using
some
of
those
compiler
return
codes
that
I
showed
at
the
beginning.
C
That's
basically
how
that
works
and
then
sort
of
some
of
the
some
of
the
other
classes,
like
the
four
Loop
Builder
I
just
mentioned
it's
just
kind
of
a
holder
for
all
of
the
useful
variables
associated
with
the
for
Loop.
If
then
has
the
same
thing
as
for
all
of
the
useful
things
associated
with
the
the,
if
then
else
so
it
knows
which
value
is
used
to
determine
which
path
is
going
to
be
executed,
and
then
it
knows
which
paths
where
the
then
and
else
path
are
Etc.
C
That's
basically
that
so,
let's
switch
to
looking
at
the
CPP
file.
So
obviously
it
needs
to
know
more
about
how
things
are
actually
implemented
and
what
things
can
be
used.
So
there's
a
whole
whackload
of
these
guys
didn't
really
have
to
include
these,
but
I
didn't
I,
didn't
I,
guess
it
could
have
gotten
it
all
from
here,
but
they're
there
anyway.
C
Some
of
the
the
symbols
that
get
created
and
the
types
that
get
created
are
all
separated
off
into
a
separate
files.
So
this
is
really
just
the
extension
object
definition
and
there
are
other
classes
that
it's
going
to
use
and
reference
as
you
as
it
goes
again.
This
is
you
know
from
the
last
presentation
we
talked
about
how
the
allocation
stuff
is
all
set
up
and
how
the
kind
service
stuff
is
set
up.
So
it's
just
straightforward
there
we
have
to
create
the
actual
semantic
version
for
that's
here,
which
are.
C
These
are
the
values
that
were
populated
from
the
header
file
up
there
in
this.
That's
why
I
had
funk
interesting
all
right
so
in
this
version
of
this
file
base
is
looking
like
it's
dependent
on
Funk,
the
funk
extension,
which
is
the
extension
that
allows
you
to
create
IL
for
functions
right
so
callable
things
that
have
parameters
and
local
variables
and
can
be
called
and
can
call
other
functions
Etc,
and
so
this
mechanism
here
is
just
the
way
of
documenting.
C
The
expectation
of
the
the
jb2
compiler
infrastructure
is
that
the
is
it
your
extensions
are
stored
in
shared
objects
and
those
shared
objects
have
a
a
particular
entry
point
called
create,
which
again
takes
a
location
and
just
the
compiler
that
the
extension
is
being
loaded
into.
So
it
gets
passed
in
by
the
compiler
when
somebody
calls
load
extension
on
the
compiler
and
gives
it
the
name
of
this
guy.
It
loads
a
shared
object
and
calls
this
create
function.
C
Passing
in
the
compiler
object
and
it's
supposed
to
pass
back
either
no
or
an
extension.
The
extension
of
the
valid
extension
object
for
for
this
extension
so
modulo
the
lack
of
error
checking
here.
This
is
allocating
a
base,
extension
object
and
and
returning
it
basically
so
that
this
is
this
is
the
this
is
the
mechanism
by
which
the
Singleton
base
extension
object
gets
created,
and
then
nothing
else
is
supposed
to
be
able
to
create
it.
C
So
nothing
else
is
supposed
to
create
one
of
these
things,
although
that's
not
really
mandated
somewhere
very
well
all
right
and
then
so.
You
notice
that
all
of
those
fields
that
were
defined
on
the
base
extension
in
the
base
extension
class
are
all
const.
That
means
they
all
have
to
be
initialized
in
the
Constructor,
which
means
that
it's
the
Constructor
that
has
to
go
and
initialize
and
register
all
of
these
things
with
the
compiler
object
so
that
they
get
installed.
So
the
core
extension
as
I
mentioned,
is
something
that
the
compiler
creates.
C
Is
not
a
great
way
of
doing
this,
but
but
I
couldn't
think
of
a
better
way
to
do
it
off
the
top
of
my
head.
Eventually,
this
will
need
to
be
not
the
compilers.
It
says.
Platform
word
size
that
really
needs
to
be
sort
of
the
code
platform
word
size
is
what
that
should
be,
as
opposed
to
the
compiler
platform
word
size
or
the
client
word
size
anyway,
that's
probably
more
subtlety
than
needed.
C
The
operations
are
all
created
by
registering
the
action
and
giving
it
a
a
string
name.
So
these
all
get
passed
in
to
the
compiler
that
what
this
boils
down
to
in
the
end
is
the
compiler
or
calls
maintains
a
list
of
actions
that
have
been
have
been
registered
and
assigns
consecutive
IDs
to
them.
In
a
you
know,
64-bit
namespace,
so
that
somebody
managed
to
just
to
create
more
than
64
bits
worth
of
operations.
C
They
could
have
different
action
action
IDs,
but
you
would
always
use
the
base
extensional
object
and
access.
What
the
what
the
type
is
here,
what
the
number
is
here
rather
than
referencing
any
specific
number,
and
so
all
of
those
go
through
exactly
the
same
process.
It's
very
similar
for
return
codes.
So
a
register
return
code
again
goes
to
the
compiler
Associates,
a
string
name
with
the
with
an
ID
that
it
just
bumps
an
ID
and
returns
it
all.
These
IDs
have
different
namespaces.
C
So
there's
one
file
in
in
the
core
compiler
infrastructure,
that's
called
ids.hp
and
it
just
has
a
whole
bunch
of
type
defs
that
give
ID
type
names
to
un6014,
so
they're
all
they're,
all
right
now
64-bit
types,
but
they
could
be
changed
independently
and
it's
it's
all
typed.
So
action,
IDs
and
compiler
return
code,
IDs
and
value
IDs
and
type
IDs
and
symbol.
C
Ids
Etc
are
all
independent,
namespaces
and
properly
checked,
and
then
Checkers
is
that
list
of
checkers,
so
it
gets
initialized
with
the
allocator
that
needs
to
be
used
to
manage
the
list,
even
though
it's
this
first
one
is
null
because
Checkers
isn't
a
is
an
embedded
object
in
the
in
the
in
in
the
extension
object.
So
this
isn't
a
dynamically
allocated
array.
Sorry
list
object.
If
it.
C
Let's
not
talk
about
that
right.
Okay,
here's
some
of
the
extensibility
mechanisms
for
the
base
extension
at
play
here,
so
this
call
goes
back
to
the
compiler
in
the
end
and
says:
for
anybody
who
creates
an
IR
object.
I
want
to
be
notified
of
that
object,
creation
and,
similarly
for
there's
a
class
called
IR
cloner,
and
that's
because
the
base
base
extension
creates
new
types
that
need
to
be
tracked
in
in
the
IR
and
what
it
does.
C
Here's
where
the
see
this,
maybe
this
is
why
I've
got
it
so
so
this
this
code
is
how
you
would
look
up
an
extension.
So
this
one's
trying
to
look
up
the
the
function
extension
basically
and
getting
a
pointer
to
it.
So
if
it
was
able
to
look
up
the
function,
extension
I.E,
if
the
function
extension
has
been
loaded,
then
then
it's
going
to
go
and
create
a
function.
Extension
specific
add-on
using
it's
going
to
add
it
to
that
extension,
object
itself.
C
I'll
show
you
what
that
is
in
a
sec
if
it
hasn't,
if
the,
if
that
extension
hasn't
been
loaded,
it
might
just
not
have
been
loaded
yet
so
so
what
it
does
is
it
registers
to
see
if
anybody
ever
creates
a
function.
Extension
object.
It
wants
to
get
notified
so
that
it
can
do
this,
create
add-on
process
here
and
I
will
go
through
I.
C
Think
some
of
that
here,
right
so
create
add-on
so
create
add-on
is
this
is
the
thing
that
gets
called
by
by
the
compiler
if,
if
an
object
of
a
particular
type
has
been
created
right
so
essentially
when,
when
a
func
function,
extension
or
an
IR
or
an
IR,
cloner
object,
that's
created,
it
calls
back
into
the
compiler
object
and
the
compiler
object
says
hey.
This
extension
wants
to
watch
for
those
allocations,
so
call
that
extension
Arrow,
create
add-on
and
pass
the
the
object
that
got
created
or
the
extension
that
created
it.
C
Actually,
it's
not
with
the
object
that
got
created
so
so
create
add-on.
Is
this
sort
of
entry
point
which
I've
leveraged
in
the
object
itself
to
here?
But
basically,
what
this
is
saying
is
that
if
an
IR
object
got
created,
then
it
will
get
called
with
that
IR
object
e
will
be
that
IR
object
if
it
got
create.
C
If
it's,
if
it's
being
called
because
an
IR
cloner
object
got
created,
it
will
pass
the
IR
cloner
object
here
and
if
it's
the
function,
an
extension
has
just
been
created
because
it's
been
loaded,
then
it
will
pass
in
with
the
function,
extension
and
so
the
function.
So
I'm
not
super
happy
with
this
dispatch
mechanism
either.
But
it's
it's
not
too
bad
yet
have
to
think
about
ways
to
make
this
a
little
bit
more
clean.
But
anyway,
right
now
it
just
uses
the
extensibility
tests
to
say
you
know:
is
it
an
IR
object?
C
Okay,
it's
an
IR
object
to
create
the
base,
IR
add-on
object
and
attach
it
to
that
to
the
to
the
to
the
base
object.
The
base
IR
object
is:
is
this
what
they
call
that
BC
anyway?
If
it's
a
function,
it's
function
extension
object.
Then
it
creates
the
base
function.
Extension
Edge
add-on
object
and
attaches
it
to
that
guy.
If
it's
the
base
I
or
if
it's
sorry,
if
it's
an
IR
cloner
object,
then
it
creates
a
base
IR
Corner
out
on
it.
These
are
all
classes
inside
the
base.
C
C
C
So
next
some
sorry
was
the
connection
between
extension
and
add-on.
Yeah,
so
extension
is
just
a
and
it's
a
it's
a
type
of
object
that
represents
a
set
of
plugable
capability
to
the
compiler
right.
So
the
base
extension
is
saying:
here's
all
this
stuff
I
want
to
inject
into
the
compiler
and
have
the
compiler
be
able
to
generate.
B
C
C
C
So
in
that
way,
somebody
that
knows
about
this
can
say:
I
want
to
load
both
of
these
things
and
I
want
to
be
able
to
use
ink
and
I'll
put
it
on
the
base.
Extension
or
sorry,
I'll
put
it
on
the
funk
extension
and
the
reason
why
that's
useful
is
because
it
means
that
base
the
base.
Extension
doesn't
have
to
depend
on
the
funk
extension.
You
know,
notwithstanding
the
code
that
I
showed
before
it
looks
like
it
depends
on
it.
C
It
doesn't
actually
depend
on
the
funk
extension,
and
so
that
means
you
could
at
some
later
date.
If
some
Intrepid
person
comes
along
and
does
it,
you
could
use
the
base
extension
for
to
compile
things
that
are
not
functions
that
are
traces
or
that
are
just
basic
blocks,
or
there
are
other
things
right,
so
I
don't
have
to
have
Funk
around
in
order
to
to
use
basic
arithmetic
and
absorb
values,
not
load,
Source,
all
right,
basic
arithmetic.
C
Needs
to
depend
on
yeah
and
the
reason
the
reason
why
I
initially
did
it
and
don't
actually
have
to
do
it
now.
The
reason
why
I
did
it
before
was
well
I,
guess,
I
still
sort
of
do,
but
the
I
used
to
have
that
Inc
function
used
to
specifically
take
a
local
symbol,
which
is
something
that's
specifically
defined
by
okay
slide
Funk
and
doesn't
exist
in
the
core
implementation,
so
bass
needed
to
have
funk
in
order
to
reference
local
symbols,
but
I
immune
like
in
principle,
you
can
do
ink
with
any
symbol
right.
C
So
it's
not.
It
doesn't
have
to
be
a
local
symbol,
so
I
just
downgraded
a
symbol,
and
now
it
kind
of
like
there's
one
of
something
knows
how
to
load
a
symbol
right.
You
just
need
load
so
but
then
in
the
end,
load
ended
up
in
Funk,
I'm,
not
actually
sure
load's
going
to
stay
in
Funk,
but
it's
there
for
now.
Right,
I've
been
toying
with
the
idea
of
moving
loads
and
store
into
the
core
extension.
Just
because,
what's
a
symbol,
if
you
can't
load
and
store
it,
but
it's
got
complications
associated
with
it.
C
C
So
this
is
creating
an
operation,
an
operation
as
part
of
the
IR,
so
it
needs
to
use
the
allocator.
That's
attached
to
the
IR
object
that
we're
that
we're
using
for
this
Builder
object.
The
idea
here
is
that
there
you
can
have
a
single
allocator
tied
to
a
particular
bunch
of
ir,
so
you
could,
if
that's
a
sort
of
bucket,
that
you
could
do
a
mass
mass
destroy
on
then
you
could.
C
C
In
principle,
this
allocator
is
still
a
raw
allocator,
so
it's
using
amount
of
free
anyway,
but
in
future
it
could
become
much
more
value,
much
more
useful.
So
to
produce
results.
You
have
to
create
values.
Extensions
are
allowed
to
create
values.
Not
everyone
is
like
outside
of
extension,
objects,
you're
not
allowed
to
create
values
willy-nilly.
C
It's
it's
part
of
the
it's
a
fundamental
enough
part
of
the
IR
that
you're
not
allowed
to
create
your
own
values,
but
but
an
extension
can
do
it.
So
it
creates
a
value,
that's
associated
with
this
Builder
and
has
the
type
of
the
of
the
literal,
and
then
that
result
and
then
it
it
uses
a
Constructor
on
op,
constant,
the
class.
C
So
there's
a
little
there's
a
few
controls
over
how
IR
objects
can
get
created
and
manipulated
and
extension
objects
are
one
of
the
more
powerful
guys
who
can
go
along
and
and
create
all
of
these
things
and
Tack
them
all
together.
But
the
idea
is
that
not
it
not
just
anyone
can
come
along
and
start
mucking
with
the
IR.
C
And
I
guess
I
can
show
you
up
cost
at
some
point.
But
let
me
let
me
go
a
little
bit
further
here.
Still,
let
me
skip
over
this
piece.
Just
a
sec,
I'm
going
to
get
to
the
add
function
so
add
is
one
of
the
ones
that
has
validation,
checking
implemented
for
it.
It's
probably
the
first
one
that
I
implemented
validation,
checking
for
so
here's
the
code
that
I
was
talking
about
before
right.
C
It's
looking
to
see
if
there
are
how
many
checker
objects
there
are,
and
if
there
are,
it
tries
to
validate
the
ad
using
one
of
them
and
if
anybody
validates
it,
then
then
that's
good,
so
it
it.
It
considers
that
to
be
valid
if
something
is
going
to,
if
if
any
of
these
validate
functions
fail
like
if
they
actually
say
no,
this
is
a
bad
combination.
That's
not
supposed
to
be
supported,
then
it's.
It
will
automatically
call
that
fail.
C
A
B
C
Basically,
it
goes
in
kind
of
a
a
reverse
order,
so
the
the
validation
Checker
associated
with
the
base
extension
is
the
guy
that
goes
last
and
everybody
else
is
supposed
to
flow.
Let
it
flow
through
if
it
if
it
doesn't
recognize
it.
So
it's
it's
kind
of
a
say.
Yes,
if
it's
good
otherwise
say
no
and
then
the
base
extension
Checker
at
the
end.
If
nobody
said
yes,
it's
a
fail,
but
I'll
show
that
in
a
sec
right.
C
So
this
is
just
a
canonicalization
step
here
and
then,
if
everything
gets
to
here,
that
means
that
the
the
left
and
right
operations
are
are
sorry.
Values
are
valid
and
we
can
create
it,
so
it
creates.
The
value,
creates
an
OP
ad,
which
is
the
class
that
corresponds
to
an
ad
operation
passes
in.
All
of
these
guys
adds
it
to
the
to
the
the
Builder
object,
B
and
Returns
the
results
of
the
the
value,
the
the
result,
value
that
got
created
all
right.
C
C
If,
if
any
aspect
of
the
values
being
passed
in
is
a
type
of
their
type,
then
they're
responsible
for,
like
a
if
the
complex
extension
saw
a
left
value
that
was
complex
or
a
right
value
that
was
complex,
then
it's
responsible
for
validating
that
operation.
Otherwise
it's
supposed
to
leave
it
alone.
So
I
can
say
yes,
but
it
can't
say
it
can't
throw
an
exception.
It
works
yeah,
it
can
say
yes,
but
it
can't
throw
an
exception
unless
it
sees
something
wrong
with
one
of
its
types.
C
It's
only
more
complicated
as
I
go.
Sorry
I'm
not
saying
this
very
succinctly
in
the
case
of
this
one,
so
it
pulls
off
the
the
types
of
the
two
operations.
It
needs
to
do
some
comparisons
with
address
and
word
to
get
this
right
and
then
it
just
does
some
validation.
So
it
says
you
know
if
the
left
type
is
an
address
and
the
right
type
isn't
word,
then
that's
not
a
valid
combination.
C
But
if
they
do
match,
then
that's
a
valid
one.
So
we
return
true
and
then
finally,
if
it
falls
through
to
here
that
means
we
haven't
seen
a
set
of
types
that
we
like.
So
it
must
be
bad,
so
we
fail
validate,
add
and
then
that
fail
validate
ad,
it's
sole
purpose
in
life.
It
gets
the
same
basic
signature
as
the
creation
of
the
operation.
So
it
sees
all
of
the
operands
that
were
passed
in.
It
creates
a
compilation
exception.
C
Using
this,
the
base
objects
compile
field
bad
input,
types
ad,
which
is
one
of
the
compiled
return
codes
that
we
registered
and
then
it
it
tacks
in
a
bunch
of
information
into
the
extent
into
this
exception,
object
that
it's
created
and
creates
a
message
that
tells
you
where
things
are
one
of
the
first
things
that
gets
displayed
when
this
error
messages,
or
when
this
exception
message
is
printed
out,
is
the
location
which
is
this
guy
that
got
passed
in.
So
you
notice
that
it
got
passed
into
the
creation
of
the
exception
object.
C
So
the
exception
also
knows
exactly
where
the
call
was
made
from
and
can
report
that
to
the
out
as
part
of
the
message,
and
then
it
throws
it.
So,
at
that
point,
you're
bailing
out
of
everything
when
you're,
when
you,
when
the
compiler,
when
you
call
compiler,
compile
this
whole
building
of
ir
processes
happening
inside
a
try
region,
so
that
the
try
region
that
catches
it
and
then
passes
back.
C
D
C
C
Executing
there's
no
fallback
anyway,
so
you're
gonna
have
to
fix
that
yeah,
but
you're
right.
That
is
a
that
is
kind
of
a
mode
I.
Guess,
let's
see,
is
there
a
way
I
could
fix
that
not
easily
not
as
easily,
maybe
anyway,
I.
Think
about
that.
It's
a
good
point.
Thank
you
right!
Okay!
So
that's
that's
ad,
then,
there's
like
all
the
different
ones
convert
to
convert
convert
to
is
for
converting
a
value
to
a
different
type,
which
is
sometimes
valid
and
sometimes
not
multiply.
Subtract
all.
C
Have
these
validations,
here's
the
for
Loop
one!
You
can
look
at
all
right
so
so
again,
there's
a
validation
for
the
for
Loop,
which
in
this
case
I
think
validate
for
Loop
only
does
oh,
it
does
allow
counters
to
be
everything,
okay,
so
any
integer
type.
Basically,
you
can
use
for
your
for
your
counter
type.
If
you
want,
and
then
it
assumes
that
all
of
the
initial
final
and
bump
are
exactly
the
same
type
that
you
said
it
should
be
I.
C
Don't
know
why
I
didn't
use
counter
type
here,
but
anyway,
I'll
fix
that
later.
So,
basically,
you
have
to
pick
an
integral
type
for
the
for
the
loop
counter
and
and
then
it
will
count
based
on
that
now
I
mean
I.
Guess
in
principle
you
could
use
a
floating
point,
but
because
it's
using
because
this
one's
currently
using
the
underlying
Omar
I
well,
the
IL
that
it
generates
with
jit
Builder
jit
builder
needs
it
to
be
an
editor
iteration
variable.
C
So
when
we,
when
I
when
I,
create
an
extension
that
goes
directly
to
the
omr
compiler
or
to
the
open
j9
compiler,
then
it
can
be
a
floating
point.
You
could
you
could?
You
know,
use
a
for
Loop
like
in
the
same
way
that
c
does
and
just
generate
a
kind
of
a
while
loop,
that
that
would
also
work
with
the
floating
Point
values
or
any
numeric
value
really
but
yeah.
C
C
That
one
is
yes
notice
that
it's
not
passing
a
pointer
back,
it's
it's,
making
a
full
copy
of
the
object.
Just
so
you
don't
have
to
manage
the
memory
got
it
yeah,
because
it's
it's
really
just
a
set
of
values.
So
it's
it's
like
a
multiple
return
value,
basically,
a
way
of
returning
multiple
return
values.
B
C
C
C
C
B
C
So
similar
things
on
the
base
namespace,
it
knows
about
base
extension,
but
doesn't
do
anything
here.
So,
okay,
what
did
I
do
here?
So
there
are
obviously
a
lot
of
different
base
types
that
the
base
extension
created,
like
int,
8
and
16
float,
32
blah
blah
blah
blah
blah.
All
of
those
types
in
this
particular
extension
I
created
a
base
class
for
all
of
those
types
just
to
be
able
to
reference
them
all.
C
So
it's
just
a
static
cast,
basically
a
basic
extension
and
then
the
next
subclass
of
Base
type
is
a
numeric
type.
So
all
the
integer
and
floating
Point
types
are
going
to
be
subclasses
of
numeric
type.
I.
Don't
actually
take
advantage
of
this
subclass
right
now,
but
it
seems
like
a
reasonable
subclass
to
have
so
so
it
it
creates
that
type
and
all
these
are
represented
in
the
kind
service.
C
C
Isn't
it
is
an
integer
type,
here's
how
the
allocation
Works
it's
a
lot
of
these
things,
I
use
the
friend
class
so
that
the
base
extension
can
create
it
without
having
a
public
instructor.
So
nobody
else
can
construct
it,
but
the
base
extension
object
can
construct
it
because
it's
Constructors
are
all
are
protected
and
then
there's
a
bunch
of
virtual
function,
API
that
the
that
type
itself
introduces.
C
So
we
haven't
seen
it
yet
because
it
was
all
hidden
underneath
base
type,
the
so
the
the
superclass
type
of
of
base
type
had
this
one
type.
So
you
can
ask,
what's
the
size
of
a
value
of
this
type,
you
can
in
principle,
you
can
ask
for
a
literal
of
a
particular
value
and
in
this
case
and
eight
because
it's
so
this
one,
it's
virtual
going
forward,
not
virtual
inherited
from
anybody
else.
C
Zero
is
the
same
way.
Identity
is
the
same
way
liter.
Oh
sorry,
identity
actually
is
one
of
the
ones.
I
think
that
it
inherits
virtually
literals
are
equal
is
a
is
a
an
inherited
virtual
thing.
So
if
I
have
two
values
of
this
type
and
and
L1
and
L2,
the
type
can
tell
me
whether
or
not
they're
equal.
C
The
reason
why
you
need
this
is
because
literals
are
there's
only
one
literal
type,
you
don't
our
literal
class
there's.
No,
you
know
intake
literal
in
16,
literal
and
32
literal.
It
literal
is
just
literal,
and
then
it
uses
a
pointer
to
a
raw
bytes
to
hold
the
actual
literal
value.
And
then
the
interpretation
of
that
thing
depends
on
what
the
type
of
the
literal
is
and
how
that's
managed.
It
is
just
basically.
C
B
C
D
C
So
it's
just
it's
a
it's
a
it's
one
way
of
looking
at
the
problem.
Okay,
you
can
either
consider
scientedness
to
be
a
property
of
the
data
or
you
can
consider
it
a
property
of
the
operations
that
process
the
data
and
and
the
the
the
the
way
that
we've
decided
to
do
that
in
Testarossa
in
the
end
was
to
make
it
a
property
of
the
operation.
So
you
use
you
do
unsigned
operations
on
data
bits
that
interpret
those
bits
as
unsigned
values
or
signed
values.
If
they're
signed
operations.
D
Yeah
I
don't
know,
maybe
I'll
push
my
example.
A
little
further,
which
byte
has
the
sign
is,
is
part
of
the
type
then
or
or
or
you
kind
of
mix
all
this
into
all
these
operations,
and
so
now
you've
got
to
add,
signed,
add
unsigned,
add
signed,
little
Indian,
add
unsigned
little
Indian
and
so
on,
and
it.
C
D
C
C
C
We've
done
it
both
ways
in
Testarossa
we
used
to
have
unsigned
data
types
in
Testarossa
and
it
ended
up
being
more
painful
to
manage
all
of
the
duplicate
like
you
know,
there's
a
whole
bunch
of
places
where
you
have
to
check.
Is
this
assigned
or
an
unsigned
int
8?
Is
it
assigned
or
an
unsigned
in
16-bit?
Is
it
assigned
or
unsigned,
because
the
thing
that
you're
doing
didn't
care-
and
you
didn't
want
to
limit
yourself
to
only
doing
it
for
one.
C
C
It's
at
the
point
where
you're
generating
the
IR
there's
a
right
way
to
generate
the
IR
and
and
it's
thinking
in
an
IR
that
Associates
sightedness
with
data.
You
do
it
one
way
and
if
there's
an
IR
that
Associates
sidedness
with
operations,
then
it
you
do
it
another
way.
But
in
the
end
it's
it's
kind
of
a
like
you
get
it,
you
get
it
right
or
you
don't
at
the
start,
and
then
the
compiler
maintains
it
from
that
point
forward.
B
C
C
When
you
do
it
right
right,
because
it
is
meant
to
be
extensible
and
you
can
add
your
own
types,
so
you
know
in
principle
someone
could
come
along
and
write
the
signed
types
extension,
which
is,
you
know,
parallel
to
the
base
extension,
which
creates
into
eight
U
and
eight
and
sn8
un
16
and
sn16
right.
You
could
do
all
of
that
and
then
build
a
whole
compiler
infrastructure
based
on
on
that
notation,
and
there
would
be
some
things
that
would
get
better
if
you
did
it
that
way.
C
C
This
these
these
types
and
this
type,
this
system
of
types
has
kind
of
evolved
over
time.
So
there
may
be
some
vestigial
stuff
in
here
that
I
just
haven't
cleaned
up.
Yet
and
beyond
that,
you
know:
that's
how
you
create
all
these
types
have
both
a
Constructor.
That's
the
way
that
the
actual
type
gets
created
in
the
first
place
by
the
base.
C
C
And
that's
and
then
all
the
other
types
are
kind
of
the
same
way.
You'll
see
the
size
keeps
getting
bigger
sizes
and
bits
just
as
a
full
generality.
There
aren't
any
types
that
are
weird
bits,
but
never
know
I
haven't
done
zos.
Yet
here's
the
next
numeric
type,
which
is
the
floating
Point
type
again,
doesn't
really
do
much
by
itself
right
now.
Full
32
extends
it
in
float.
B
C
Way
that
pointers
get
created
is
through
a
builder
object
kind
of
approach
too,
as
well
as
structs.
Structs
is
a
really
interesting
one,
but
I'll
start
with
pointers.
So
so
a
pointer
type
has
a
base
type
and
so
they're
the
way
that
the
actual
pointer
type
gets
created.
Is
you
create
a
pointer
type,
build
or
object?
You
set
what
the
base
type
is
and
if
you
need
a
helper
in
order
to
create
it
and
I'm
going
to
go
into
that
detail,
the
the
helper
object.
C
The
helper
thing
is
basically
a
way
of
creating
recursive
types,
types
that
reference
themselves
right.
So
if
I
wanted
to,
if
I
have
a
pointer
type
inside
a
struct
that
points
to
the
next
field,
that's
the
that's!
Actually,
not
the
good,
not
the
best
example,
in
fact,
pointer
to
I
had
pointer
to
pointer
to
pointer
to
around
would
that
work
you
create
a
type
like
that
sounds
awful
I,
don't
want
to
type
that
the
example
works
better
for
struct.
C
C
So
you
have
this
type
Builder
you
take
that
object,
call
set
base
type
and
pass
a
type
to
it,
and
then
you
you
pass
a
create
and
then
it
will
create
the
type
and
return
it
to
you
and
it's
just
so
in
pointers,
it's
fairly
straightforward,
the
actual
pointer
types
that
it
creates
are
actually
part
of
address
type
they're,
a
subclass
of
address
type.
They
have
all
the
same
kinds
of
goodies
that
the
other
things
have
ignore.
That
for
now
actually
just
ignore
that
I.
C
Don't
want
to
talk
about
that
today
and
that's
it
yeah.
So
it
adds
a
base.
Type
pointer
here.
Note
that
type
pointers
are
all
constant.
So
once
you
create
a
type,
you
can't
change
it.
Whatever
that's
kind
of
by
Design
It
Is
by
Design,
all
right
structs
are
created.
There
are
both
types
that
represent
an
entire
struct
and
then
there's
a
type
that
represents
the
fields
of
a
struct.
C
So
if
your
field
is
an
INT
8,
there's
a
field
type
that
says
I'm
a
field
that
has
an
INT
8
that
has
this
name
and
I'm
a
member
of
this
struct
type.
So
there's
all
that
sort
of
structure
around
how
struct
types
are
built
up
and
when
I
say
struct,
it's
also
Union,
because
the
offset
of
the
field
within
the
struct
can
there's
no
requirement
that
they
don't
overlap
or
that
you
know
you
can
do
all
kinds
of
crazy
stuff
if
you
really
wanted
to,
but
all
it
does
all
it
does
verify.
I.
C
Think
right
now
is
that
the
size
of
the
struct
type
there's
no
field
that
extends
outside
of
the
size
of
the
struct
type.
Basically,
it
constructs
the
struct
type.
That
way,
but
this
is
this-
is
a
so
so
field
type
Fields,
every
field
type
knows
which
struct
it's
a
part
of
what
the
name
of
the
field
is,
what
the
type
of
the
field
is,
and
what
offset
in
the
struct
is
The
Field's
at
right.
C
So
those
are
sort
of
the
basic
pieces
of
a
field
type
and
you
you
can
already
sort
of
see
the
recursiveness
of
this
like
the
field
type
needs
to
know
the
struct
type
and
then
obviously
the
struct
type
is
going
to
have
a
list
of
the
field
types
too,
so
that
recursive
nature
already
exists
just
in
a
single
struct,
and
then
you
need
a
way
to
be
able
to
create
these
things
and
make
them
cost
pointers,
because
all
types
are
const.
So
so
that's
where
the
struct
type
Builder
guy
comes
in
to
play.
C
So
this
guy
kind
of
basically
just
builds
up
a
representation
of
what
the
fields
are
without
actually
creating
the
field
types
yet
and
then
so
it
kind
of
you.
You
can
set
the
name
of
the
struct,
you
can
add
a
field
and
a
field
has
a
name
and
a
type
and
an
offset,
but
this
doesn't
create
the
field
type.
C
Yet
it's
only
when
you
actually
call
the
create
that
it
ends
up
creating
the
actual
struct
and
field
types,
and
this
is
where
the
helper
thing
makes
a
lot
more
sense,
because
if
you
had
a
recursive
struct
like
a
list
element,
it
has
to
have
a
pointer
to
this,
like
the
field
type
has
to
have
a
pointer
back
to
the
struct
type.
So
it's
the
same
kind
of
thing
and
the
helper
is
a
way
for
it.
C
You
to
add
so
the
helper
is
called
beef
as
part
of
the
creation
process,
but
before
any
of
the
field
types
get
created.
So
it's
a
way
to
inject.
Add
Fields
after
the
struct
type
has
been
created,
so
you're
being
called
in
the
middle
of
creating
the
struct
type,
so
the
struct
type
pointer
exists
which
you're
not
allowed
to
change,
and
obviously
it
doesn't
have
very
much
information
in
it
yet.
C
But
you
are
allowed
to
call
add
fields
from
there
to
say:
I
want
to
add
a
field
that
has
a
pointer
like
you
can
create
a
pointer
type
that
points
at
the
struct
type
because
it's
now
been
created
and
then
you
can
create.
You
can
add
a
field
that
points
to
that
to
that
pointer
type
and
then,
once
the
helper
is
finished,
then
the
then
it
will
go
through
and
process
all
the
fields
that
have
been
created
in
its
list
and
and
set
up
the
actual
struct.
C
So
it's
a
it's
a
it's
a
little
bit
quirky,
but
it
it
it
manages
to.
Let
me
keep
all
of
the
types
as
const
which
I
thought
was
a
very
useful
property
and
yet
still
be
able
to
create
recursive
struct
types
and
do
interesting
things
anyway,
so
yeah,
so
it
has
a
you,
know,
create
and
verify,
and
blah
blah
blah
and
I
used
to
think
I
needed
unions,
but
I,
don't
so
yeah
yeah
an
instruct
type
just
has
a
this
has
actually
a
very
old.
C
B
C
Didn't
realize
I
was
using
multi-map,
damn
it
two
more
sdl
containers
to
get
rid
of.
You
got
a
couple
minutes
left
yeah,
I'm,
gonna,
I'm
gonna
wrap
up
there,
because
that's
kind
of
the
end
and
I
I
do
have
a
meeting
in
two
minutes.
So
every
one
of
these
presentations
has
gone
for
90
minutes.
So
I
my
throat
is
getting
raw
as
I'm
talking
through
this
I
hope.
I
hope
that
was
useful
for
people
and
you
found
it
interesting
to
see
the
code.
I
guess.
C
One
other
thing
I'll
point
out,
although
I
have
a
counter
example
on
this
on
the
screen.
Where
do
I
have
a
good
here,
I
mean
one
of
the
other
things
that
you
get
a
flavor
for
in
this
is
code.
Is
the
coding
the
code
formatting
that
I've
been
using
for
this
whole
code
base,
although
obviously
not
consistently,
because
there's
a
counter
example
here,
but
where
I
ended
up
falling
into
the
Testarossa
scheme,
but
anyway,
for
the
most
part
I'm
using
the.