Implemented reading from struct fields

src/core/CompileAssignField.go

@@ -24,21 +24,19 @@ func (f *Function) CompileAssignField(node *ast.Assign) error {
 	defer f.UseVariable(variable)
 	pointer := variable.Type.(*types.Pointer)
 	structure := pointer.To.(*types.Struct)
+	field := structure.FieldByName(fieldName)
 
-	for _, field := range structure.Fields {
-		if field.Name == fieldName {
-			memory := asm.Memory{
-				Base:           variable.Register,
-				Offset:         field.Offset,
-				OffsetRegister: math.MaxUint8,
-				Length:         field.Type.TotalSize(),
-			}
-
-			_, err := f.ExpressionToMemory(value, memory)
-			return err
-		}
+	if field == nil {
+		return errors.New(&errors.UnknownStructField{StructName: structure.Name, FieldName: fieldName}, f.File, destination.Children[1].Token.Position)
 	}
 
-	// TODO: unknown field error
-	return nil
+	memory := asm.Memory{
+		Base:           variable.Register,
+		Offset:         field.Offset,
+		OffsetRegister: math.MaxUint8,
+		Length:         field.Type.TotalSize(),
+	}
+
+	_, err := f.ExpressionToMemory(value, memory)
+	return err
 }

src/core/ExpressionToRegister.go

@@ -44,6 +44,17 @@ func (f *Function) ExpressionToRegister(node *expression.Expression, register cp
 		return types.Int, err
 	}
 
+	if node.Token.Kind == token.Period {
+		left := node.Children[0]
+		name := left.Token.Text(f.File.Bytes)
+		variable := f.VariableByName(name)
+		right := node.Children[1]
+		name = right.Token.Text(f.File.Bytes)
+		field := variable.Type.(*types.Pointer).To.(*types.Struct).FieldByName(name)
+		f.MemoryRegister(asm.LOAD, asm.Memory{Base: variable.Register, Offset: field.Offset, Length: field.Type.TotalSize()}, register)
+		return field.Type, nil
+	}
+
 	if len(node.Children) == 1 {
 		if !node.Token.IsUnaryOperator() {
 			return nil, errors.New(errors.MissingOperand, f.File, node.Token.End())

src/errors/UnknownStructField.go

@@ -0,0 +1,19 @@
+package errors
+
+import "fmt"
+
+// UnknownStructField represents unknown struct fields.
+type UnknownStructField struct {
+	StructName       string
+	FieldName        string
+	CorrectFieldName string
+}
+
+// Error generates the string representation.
+func (err *UnknownStructField) Error() string {
+	if err.CorrectFieldName != "" {
+		return fmt.Sprintf("Unknown struct field '%s' in '%s', did you mean '%s'?", err.FieldName, err.StructName, err.CorrectFieldName)
+	}
+
+	return fmt.Sprintf("Unknown struct field '%s' in '%s'", err.FieldName, err.StructName)
+}

src/types/Struct.go

@@ -14,3 +14,13 @@ func (s *Struct) UniqueName() string {
 func (s *Struct) TotalSize() uint8 {
 	return s.Size
 }
+
+func (s *Struct) FieldByName(name string) *Field {
+	for _, field := range s.Fields {
+		if field.Name == name {
+			return field
+		}
+	}
+
+	return nil
+}