simplify expr by merging all simple eval functions
into a single eval interface{}.
R=austin
DELTA=1597 (730 added, 780 deleted, 87 changed)
OCL=34182
CL=34198
compilation to put the definitions in reasonable places. No
code changes, just movement.
R=rsc
APPROVED=rsc
DELTA=479 (232 added, 247 deleted, 0 changed)
OCL=34067
CL=34069
for built-in functions and type conversions. Extract out
common operations on expression nodes for converting them to
ints and implicitly dereferencing arrays.
R=rsc
APPROVED=rsc
DELTA=442 (365 added, 50 deleted, 27 changed)
OCL=34064
CL=34064
code assumes that the definition of a named type is not a
named type, but some code paths could violate that.
R=rsc
APPROVED=rsc
DELTA=9 (5 added, 2 deleted, 2 changed)
OCL=34046
CL=34053
In the process, I made error handling in the statement
compiler much saner. Instead of separately tracking various
error flags with weird relations, I just track if any error
messages have been produced.
R=rsc
APPROVED=rsc
DELTA=308 (98 added, 135 deleted, 75 changed)
OCL=33870
CL=33961
statement compiler will be fixed in a later CL.
The input and output of the expression compiler are now
clearly distinguished. In the process, I made the individual
expression compilers operate on the compiled form of their
children instead of AST nodes. As a result, there are now
fewer places where I hand-craft intermediate expression nodes.
The diff looks scarier than it is, mostly because exprCompiler
has been split into the input and output types, resulting in
lots of little renames.
R=rsc
APPROVED=rsc
DELTA=774 (204 added, 199 deleted, 371 changed)
OCL=33851
CL=33851
variables to be given initial values in some cases, to make
building global scopes more convenient.
R=rsc
APPROVED=rsc
DELTA=29 (17 added, 0 deleted, 12 changed)
OCL=33760
CL=33766
type switch on them despite their private fields. Add some
tracing stuff.
R=rsc
APPROVED=rsc
DELTA=18 (7 added, 0 deleted, 11 changed)
OCL=33678
CL=33683
types were supposed to be identical but only needed to be
compatible. This gets rid of the Type.literal method. I
renamed the Type.rep method to Type.lit because I believe it
corresponds to the term "literal" as used in the spec.
R=rsc
APPROVED=rsc
DELTA=228 (57 added, 35 deleted, 136 changed)
OCL=32606
CL=32608
the position where they were defined so I can produce good
error messages on redefinitions.
R=rsc
APPROVED=rsc
DELTA=204 (126 added, 13 deleted, 65 changed)
OCL=32599
CL=32605
Return checking is now done as a general flow check at the end
of function compilation, since break and goto complicated the
way I was doing return checking before. Goto-over-declaration
checking is also done as a final flow check.
Temporary variables used for effect extraction are now
actually temporary. Otherwise "op=", "++", and "--" appear as
declarations that cannot be jumped over.
R=rsc
APPROVED=rsc
DELTA=421 (344 added, 38 deleted, 39 changed)
OCL=32527
CL=32535
single frame and non-overlapping variables reuse frame slots.
As a result, entering and exiting blocks no longer requires
code execution, which means jumps across block boundaries
should be doable now. Frame slot initialization happens at
definition time now, instead of at frame creation time. As an
added bonus, Scope's are now exclusively compile-time objects
and we no longer need to specially track the function
activation frame for access to out vars.
R=rsc
APPROVED=rsc
DELTA=313 (102 added, 90 deleted, 121 changed)
OCL=32416
CL=32420
and decrement. blockCompilers now form a tree the mimics the
nesting of scopes and provide convenient ways to enter and
exit scopes. blockCompilers also track the break and continue
PC for the current block. The statement testing interface now
works in lists of statements, which simplifies a bunch of
things.
R=rsc
APPROVED=rsc
DELTA=401 (335 added, 44 deleted, 22 changed)
OCL=32308
CL=32317
unpacking for assignments, call arguments, and returns. This
change revamps the whole assignment compilation system to be
multi-valued, using the new MultiType type and multiV value.
Function calls, returns, and assignments now share a lot of
code and produce very consistent error messages.
R=rsc
APPROVED=rsc
DELTA=510 (335 added, 74 deleted, 101 changed)
OCL=32248
CL=32258
function calling. Implement a type compiler and named types.
Implement a universal scope containing built-in named types,
and some built-in constants. Implement a simple virtual
machine for executing statements and single-valued return.
Fix many places that incorrectly dealt with named types. In
particular, the Type.Zero methods now use the type's bit count
to determine the appropriate value representation. As a
result, a bit count of 0 now means architecture-dependent and
bounded types use unsafe.Sizeof to determine the correct
bounds. Previously, the bounds on a 32-bit machine would have
been wrong.
Eliminated Type.compatible, since the implementation is
equivalent for all types. Added Type.rep that shallowly
strips named types. Replaced almost all uses of Type.literal
with Type.rep.
Fix implementation of assign-op's so it only evaluates the
left side once. As part of this, there is now a generic way
to separate out the effect and value of an expression.
R=rsc
APPROVED=rsc
DELTA=1530 (1244 added, 68 deleted, 218 changed)
OCL=32184
CL=32230
all type-specific value functions, and use ZeroVal to create
new frames. Remove Value.Type; it was unused and difficult
for values with composite types. Add Value.Assign methods.
R=rsc
APPROVED=rsc
DELTA=282 (135 added, 90 deleted, 57 changed)
OCL=31894
CL=31930
Some cleanup. Elem() on PtrType is now just Elem and matches
with ArrayType. Generators now switch over the result type
instead of the operand type. Delete unused diag function.
R=rsc
APPROVED=rsc
DELTA=281 (219 added, 18 deleted, 44 changed)
OCL=31876
CL=31891
them as we go.
Lots of bug fixes. Let the parser toss illegal character and
string literals. Compile unary + correctly. Allow float OP
ideal. Compile unary * correctly. Implement min and max float
values.
R=rsc
APPROVED=rsc
DELTA=64 (29 added, 7 deleted, 28 changed)
OCL=31811
CL=31814
considered running, so WaitStop doesn't lock up and
breakpoints get installed and uninstalled. We also don't try
to detach from them, since that will fail.
R=rsc
APPROVED=rsc
DELTA=35 (26 added, 2 deleted, 7 changed)
OCL=31683
CL=31731
container for values.
Instead of having one evaluator function that returns a
generic Value, there is now an evaluator function for each
generalized type that simply returns a native type.
The compiler is more type-safe now because there are almost no
type conversions at evaluation time and it's impossible to
invoke a nil evaluator function during evaluation. This also
makes ideals and pointers really clean.
As an added bonus, expression evaluation should be faster
because it doesn't require heap allocation for every
intermediate value, type switches, or lots of conversions to
and from Value. It also involves fewer function calls.
R=rsc
APPROVED=rsc
DELTA=431 (280 added, 115 deleted, 36 changed)
OCL=31705
CL=31709
