Method Process

asm/assembler.go:42–95

(codeStartOffset uint16, instructions []Instruction)

}

func (a *Assembler) Process(codeStartOffset uint16, instructions []Instruction) ([]uint16, error) {
	a.labels = make(map[string]uint16)
	a.symbols = make(map[string]uint16)
	position := uint16(0)

	//calculate labels and symbols
	for _, ins := range instructions {
		position += uint16(ins.Size())

		if label, ok := ins.(DEFLABEL); ok {
			if _, ok := a.labels[label.Name]; ok {
				return nil, fmt.Errorf("label '%s' already exists, all labels should be unique", label.Name)
			}

			a.labels[label.Name] = position + codeStartOffset
		}

		if symbol, ok := ins.(DEFSYMBOL); ok {
			if _, ok := a.symbols[symbol.Name]; ok {
				return nil, fmt.Errorf("symbol '%s' already exists, all symbols should be unique", symbol.Name)
			}

			if isReservedSymbol(symbol.Name) {
				return nil, fmt.Errorf("symbol '%s' is reserved for internal use, please use another symbol name", symbol.Name)
			}

			a.symbols[symbol.Name] = symbol.Value
		}
	}

	emitted := []uint16{}

	position = 0
	for index, ins := range instructions {
		if _, ok := ins.(DEFLABEL); ok {
			continue
		}
		if _, ok := ins.(DEFSYMBOL); ok {
			continue
		}

		a.symbols[CURRENTINSTRUCTION] = position + codeStartOffset
		a.symbols[NEXTINSTRUCTION] = getNextExecutableInstructionLoc(a.symbols[CURRENTINSTRUCTION], index, instructions)
		emit, err := ins.Emit(a.ResolveLabel, a.ResolveSymbol)
		if err != nil {
			return nil, err
		}

		emitted = append(emitted, emit...)
		position += uint16(ins.Size())
	}

	return emitted, nil
}

func (a *Assembler) ToString(codeStartOffset uint16, instructions []Instruction) (string, error) {
	a.labels = make(map[string]uint16)