module Z80::Program

# File lib/z80/labels.rb, line 61
def [](label)
        label = label.first while label.is_a?(Array)
        if label.respond_to?(:to_label) || label.is_a?(Register)
                label[]
        elsif label.is_a?(Condition)
                raise Syntax, "Invalid pointer argument."
        else
                Label.new(label.to_i, 1)[]
        end
end

# File lib/z80/labels.rb, line 259
def addr(address, type = 1, align: 1, offset: 0)
        if address == :next
                last_label = @labels.values.last
                raise Syntax, "There is no label added to the program yet." if last_label.nil?
                addr last_label[1], type, align:align, offset:offset
        else
                address = address.to_i
                align = align.to_i
                raise ArgumentError, "align must be >= 1" if align < 1
                address = (address + align - 1) / align * align + offset.to_i
                Label.new address, type
        end
end

# File lib/z80/labels.rb, line 143
def address?(arg)
        arg = arg.first while arg.is_a?(Array)
        arg.is_a?(Integer) or arg.respond_to?(:to_label)
end

# File lib/z80/labels.rb, line 225
def alias_label(address, align: 1, offset: 0)
        align = align.to_i
        offset = offset.to_i
        raise ArgumentError, "align must be >= 1" if align < 1
        if address.respond_to?(:to_alloc)
                offset = offset.to_i
                address = (address + align - 1) / align * align if align > 1
                address = address + offset unless offset.zero?
                Alloc.new(address, :alias).tap do |alc|
                        @reloc << Relocation.new(pc, alc, :alias, nil)
                        @debug << DebugInfo.new(pc, 0, '---> %04xH', [nil, :alias], @context_labels.dup << alc)
                end
        else
                raise ArgumentError, "address must be a label or a lazy expression"
        end
end

# File lib/z80/labels.rb, line 421
def bytes(*args); data(1, *args); end

# File lib/z80/labels.rb, line 358
def data(type = 1, size = nil, *args)
        res = ''
        from = 0
        case type
                when :jr, :pc, :self
                        from = type
                        type = 1
        end
        if type.respond_to? :to_data
                unless Integer === size
                        args.unshift size
                        size = args.length
                end
                type_size = type.to_i
                size.times do |i|
                        res << type.to_data(self, i*type_size, args.shift)
                end
                size = nil
        elsif type.is_a?(String)
                res << type
                type = Integer === size ? size : res.bytesize
        else
                bsize = type.to_i
                raise Syntax, "Invalid data type" unless bsize == 1 || bsize == 2
                if Integer === size
                        size *= bsize
                else
                        args.unshift size
                        size = nil
                end
                pack_string = bsize == 1 ? 'c' : 's<'
                args.flatten.each_with_index do |data, index|
                        res << 
                        if data.respond_to? :to_label
                                case bsize
                                when 1 then Z80::add_reloc(self, data, 1, index, from)
                                when 2 then Z80::add_reloc(self, data, 2, index*2)
                                end
                        elsif data.respond_to? :to_z80bin
                                data.to_z80bin
                        elsif Integer === data
                                [data].pack(pack_string)
                        else
                                data.to_s
                        end
                end
        end
        if size
                res = res.ljust(size, "\x0") if res.bytesize < size
                res.slice!(size..-1)
        end
        Z80::add_code(self, res.force_encoding(Encoding::ASCII_8BIT), type)
end

# File lib/z80/labels.rb, line 428
def db(*args); data(1, args); end

# File lib/z80.rb, line 676
def debug_comment(text=''.freeze)
                @debug << DebugInfo.new(pc, 0, text.to_s, nil, [Label.dummy])
end

# File lib/z80/labels.rb, line 466
def define_label(name, label=nil)
        raise "there is no context for a label" unless (ct = @contexts.last)
        name = name.to_s
        if label
                label = if label.respond_to?(:to_label)
                        label.to_label self
                else
                        Label.new label.to_i, 1
                end
                dummies_deleted = @dummies.reject! do |n, lbl, *cts|
                        if n == name and cts.include? ct.object_id
                                lbl.reinitialize label
                                label.name = name
                                true
                        else
                                false
                        end
                end
                # make sure aliased labels (allocs) gets undummied too
                unless dummies_deleted.nil?
                        @dummies.delete_if {|_, lbl, *_| !lbl.dummy? }
                end
                if ct.has_key? name
                        ct[name].reinitialize label
                        label.name = name
                else
                        label.name = name
                        ct[name] = label
                end
                if @autoexport and @contexts.length == 1
                        export ct[name]
                else
                        ct[name]
                end
        else
                ct[name]||= Label.dummy(name).to_alloc
        end.tap do |label|
                label.name = name
                @labels.delete name # move label to last position
                @labels[name] = label
        end
end

# File lib/z80/labels.rb, line 152
def direct_address?(arg)
        arg.is_a?(Integer) or direct_label?(arg)
end

# File lib/z80/labels.rb, line 119
def direct_label?(arg)
        arg.respond_to?(:to_label) and !pointer?(arg)
end

# File lib/z80/labels.rb, line 446
def dw(*args); data(2, args); end

# File lib/z80/labels.rb, line 27
def export(label)
        raise Syntax, "Only labels on the top level may be exported" if @contexts.length != 1
        case label
        when :auto
                @autoexport = true
        when :noauto, :no_auto
                @autoexport = false
        else
                name = label.to_name
                raise Syntax, "No label name for export: #{label.inspect}." if name.nil? || name.empty?
                @exports[name.to_s] = label
        end
end

# File lib/z80/labels.rb, line 175
def immediate?(arg)
        arg = arg.first while arg.is_a?(Array)
        label_immediate?(arg) or arg.is_a?(Integer)
end

# File lib/z80.rb, line 554
def import(program, name=nil, labels:true, code:true, macros:false, override:{}, args:[])
        if program.is_a?(Symbol)
                program, name = name, program
        end

        raise Syntax, "modules may not be imported from under namespaces" if @contexts.length != 1

        addr = pc
        raise ArgumentError, "override should be a map of override names to labels" unless override.respond_to?(:map)
        override = override.map do |n,v|
                v = case v
                when Integer
                        Label.new(v, 0)
                when Label, Alloc
                        v
                else
                        raise ArgumentError, "override: #{n} is not a label or an address"
                end
                [n.to_s, v]
        end.to_h

        code_addr = if code.respond_to?(:to_i)
                code.to_i
        end

        if macros
                self.extend program::Macros if defined?(program::Macros)
        end

        if labels
                label_addr, absolute = if labels.respond_to?(:to_i)
                        [labels.to_i, true]
                else
                        [addr, false]
                end
                members = Hash[program.exports.map {|n, l|
                        raise Syntax, "only named labels may be exported" if l.to_name.nil?
                        [n, l.deep_clone_with_relocation(label_addr, absolute, override)]
                }]
        end

        type = code ? program.code.bytesize : 0

        if name
                plabel = Label.new(addr, type, :code, members)
                self.define_label name, plabel
        else
                members.each {|n, m| self.define_label n, m} if members
                plabel = Label.new addr, type, :code
        end

        if code and !program.code.bytesize.zero?
                @debug << DebugInfo.new(addr, 0, nil, nil, @context_labels.dup << plabel)
                @debug << @imports.size
                @imports << [addr, type, program, code_addr, args, name, override]
                @code << program.code
                program.code.freeze
        end

        program.freeze if labels or code
        plabel
end

# File lib/z80.rb, line 637
def import_file(file, type = :any, size = nil, pipe:nil, check_size:nil, data_type:nil, **args)
        type = type.to_s.upcase.to_sym
        if type == :ANY
                type = File.extname(file).gsub(/^\./,'').upcase.to_sym
        end
        data = if Z80.constants.include?(type) and (handler = Z80.const_get(type)) and (handler.respond_to? :read_data)
                $stderr.puts "Importing #{type} file: `#{file}'."
                handler.read_data(file, args)
        else
                $stderr.puts "Importing binary file: `#{file}'."
                File.open(file, 'rb') {|f| f.read}
        end
        if Integer === check_size
                raise CompileError, "size does not match the imported file size: #{check_size} != #{data.bytesize}" if check_size != data.bytesize
        end
        unless pipe.nil?
                raise ArgumentError, "pipe should be a proc" unless pipe.respond_to? :call
                data = pipe.call data
        end
        if data_type.nil?
                data_type = size || data.bytesize
        end
        Z80::add_code self, if size
                data[0, size].ljust(size, "\x0")
        else
                data
        end, data_type
end

# File lib/z80.rb, line 331
def isolate(name = nil, **opts, &block)
        ns(name, **opts, isolate: true, &block)
end

# File lib/z80/labels.rb, line 193
def label(type = 1, align: nil, offset: 0)
        lbl = Label.new pc, type, :code
        if align.nil? and offset == 0
                @debug << DebugInfo.new(pc, 0, nil, nil, @context_labels.dup << lbl)
        else
                if align
                        align = align.to_i
                        raise ArgumentError, "align must be >= 1" if align < 1
                        lbl = (lbl + align - 1) / align * align
                end
                lbl = lbl + offset unless offset == 0
        end
        lbl
end

# File lib/z80/labels.rb, line 110
def label?(arg)
        arg = arg.first while arg.is_a?(Array)
        arg.respond_to?(:to_label)
end

# File lib/z80/labels.rb, line 93
def label_defined?(name)
                @labels.has_key? name.to_s
end

# File lib/z80/labels.rb, line 161
def label_immediate?(arg)
        arg = arg.first while arg.is_a?(Array)
        if arg.respond_to?(:immediate?)
                arg.immediate?
        else
                label?(arg) and arg.to_label(self).immediate?
        end
end

# File lib/z80.rb, line 522
def label_import(program, name = nil, labels:true, macros:false)
        import program, name, code: false, labels: labels, macros: macros
end

# File lib/z80.rb, line 507
def macro_import(program)
        import program, code: false, macros: true, labels: false
end

# File lib/z80/labels.rb, line 533
def method_missing(m, label = nil)
        if m == :to_ary || m == :to_a || m == :to_hash || m == :to_h
                super
        else
                define_label(m, label)
        end
end

# File lib/z80.rb, line 198
def new(start = 0x0000, *args, override:{})
        raise ArgumentError, "override should be a map of override names to labels" unless override.respond_to?(:to_h)
        override = Alloc.compile(override, 0, include_sizes:false)

        unless @dummies.empty? and !@contexts.last.any? {|_,v| v.dummy?}
                dummies = @dummies.map {|d| d[0..1]} + @contexts.last.select {|_,v| v.dummy?}.map {|d| d[0..1]}
                dummies.reject! {|n,_| override.has_key?(n) }
                unless dummies.empty?
                        raise CompileError, "Labels referenced but not defined in #{self}: #{dummies.inspect}"
                end
        end

        prog = super(*args)
        code = @code.dup

        imports = Hash[@imports.map do |addr, size, program, code_addr, arguments, name, import_override|
                merged_override = Alloc.compile(import_override, start, override, include_sizes:false)
                if name.nil?
                        merged_override.merge!(override)
                else
                        prefix = name.to_s + '.'.freeze
                        merged_override.merge!(override.
                                select{ |k,| k.start_with?(prefix) }.
                                map{ |k,v| [k.slice(prefix.length..-1), v] }.
                                to_h)
                end

                code_addr = addr + start if code_addr.nil?
                ip = program.new(code_addr, *arguments, override:merged_override)
                raise CompileError, "Imported program #{program} has been modified." unless ip.code.bytesize == size
                code[addr, size] = ip.code
                [name.nil? ? addr + start : name.to_sym, ip]
        end]

        labels = Alloc.compile(@labels, start, override)

        reloc = @reloc.dup
        debug = @debug.dup
        @conditional_blocks.each do |cndblk|
                raise CompileError, "Invalid conditional block program" unless cndblk.program.equal?(self)
                ConditionalBlock.compile(cndblk, code, reloc, debug, start, override)
        end

        aliases = {}

        reloc.each do |r|
                case r.size
                when :alias
                        aliases[r.alloc] = r.alloc.to_i(start, override:override)
                when 0
                        raise CompileError, "Absolute labels need relocation sizes for the overrides"
                        # OBSOLETE: ignore, this is an absolute address but we need relocation info for debug
                when 1
                        addr = case r.from
                        when Integer
                                r.from
                        when :jr, nil
                                r.addr + 1 + start
                        when :pc
                                r.addr + start
                        when :self
                                :self
                        else
                                raise CompileError, "Unknown from relocation parameter: #{r.inspect}"
                        end
                        i = r.alloc.to_i(start, addr, override:override)
                        if (r.from.nil? or r.from == :jr) and !(-128..127).include?(i)
                                raise CompileError, "Relative relocation out of range at 0x#{'%04x' % r.addr} -> #{i} #{r.inspect}"
                        end
                        if r.from == :pc and !(0..255).include?(i)
                                raise CompileError, "Jump table relocation out of range at 0x#{'%04x' % r.addr} -> #{i} #{r.inspect}"
                        end
                        code[r.addr] = [i].pack('c')
                when 2
                        code[r.addr, 2] = [r.alloc.to_i(start, override:override)].pack('S<')
                else
                        code[r.addr, r.size] = [r.alloc.to_i(start, override:override)].pack('Q<')[0, r.size].ljust(r.size, "\0")
                end
        end
        ['@code', code,
         '@org', start,
         '@debug', nil,
         '@labels', labels,
         '@imports', imports,
         '@reloc_info', reloc,
         '@debug_info', debug,
         '@alias_info', aliases,
        ].each_slice(2) do |n,v|
                prog.instance_variable_set n,v
        end
        prog
end

# File lib/z80.rb, line 382
def ns(name = nil, **opts)
        raise ArgumentError, "no block given to ns" unless block_given?
        # Save parent labels
        labels = @labels
        @labels = labels.dup
        # Normalize inherit option
        inherit = opts[:inherit] || opts[:inherit_absolute] || opts[:inherit_labels] || opts[:use]
        inherit = [inherit] if !inherit.is_a?(Array) &&
                                                        (inherit.is_a?(Symbol) || inherit.is_a?(String) || label?(inherit))
        # Looks for labels in every context
        find_1st_defined_label_in_contexts = ->(name) do
                ct = @contexts.reverse_each.find do |ct|
                        l = ct[name]
                        l and !l.dummy?
                end
                ct and ct[name]
        end
        # Handle inherit option
        @contexts << if inherit.is_a?(Array)
                inherit.map do |name|
                        name = if name.respond_to?(:to_name)
                                name.to_name
                        else
                                name.to_s
                        end
                        labl = labels[name]
                        if labl and labl.dummy?
                                labl = find_1st_defined_label_in_contexts[name]
                        end
                        raise CompileError, "Label: `#{name}' not found" if labl.nil?
                        [name, labl]
                end.to_h
        elsif inherit == true
                labels.select do |name,label|
                        if label.dummy?
                                label = find_1st_defined_label_in_contexts[name]
                        end
                        label && label.immediate?
                end
        elsif !inherit
                {}
        else
                raise ArgumentError, "ns :inherit option must be a boolean, name or array of names"
        end
        # Prepare top and eoc labels
        addr = pc
        top = Label.dummy
        eoc = Label.dummy 'EOC'
        # Prepare debug info for a namespace
        begin_reloc_index = @reloc.length
        begin_debug = DebugInfo.new(addr, 0, '--- begin ---', nil, @context_labels.dup << top)
        @debug << begin_debug
        @context_labels << top unless opts[:merge]
        # Execute block
        yield eoc
        # Check if eoc was used and modify debug info accordingly
        if @reloc[begin_reloc_index...@reloc.length].any? {|r| Alloc.include?(r.alloc, eoc) }
                @debug << DebugInfo.new(pc, 0, '---  end  ---', nil, @context_labels.dup << eoc)
        else
                begin_debug.text = nil
        end
        # Finally define eoc label
        eoc.reinitialize(pc, 1, :code)
        # Restore parent labels
        @labels = labels
        # Get our context's id
        context_id = @contexts.last.object_id
        # Partition labels created in this context
        members, dummies = @contexts.pop.partition do |_, l|
                if l.dummy?
                        false
                else
                        true
                end
        end
        # Handle dummies left by inner namespaces
        @dummies.delete_if do |name, label, *cts|
                if cts.include?(context_id) and @labels.has_key?(name) and !@labels[name].dummy?
                        label.reinitialize @labels[name]
                        true
                else
                        false
                end
        end
        # Prepare contexts array for dummies
        contexts = @contexts.map(&:object_id)
        # Handle isolate option
        if opts[:isolate]
                unless dummies.empty?
                        dummies = dummies.map {|d| d[0..1]}
                        raise CompileError, "Undefined labels referenced in isolated namespace: #{dummies.inspect}"
                end
        else
                @dummies+= dummies.map do |name, label|
                        if @labels.has_key?(name) and !@labels[name].dummy?
                                label.reinitialize @labels[name]
                                nil
                        else
                                # register dummy alias labels
                                members << [name, label] if label.alias?
                                [name, label] + contexts
                        end
                end.compact
        end
        # Handle merge option
        if opts[:merge]
                members.each {|n, l| self.define_label(n, l) }
                top.reinitialize addr, pc - addr, :code
        else
                # Remove our context from debug info
                @context_labels.pop
                top.reinitialize addr, pc - addr, :code, Hash[members]
        end
        # Optionally give name to top label
        top = self.define_label name, top if name
        top
end

# File lib/z80.rb, line 311
def org(address = pc, pad = 0, align: 1, offset: 0)
        address = address.to_i
        align = align.to_i
        raise ArgumentError, "align must be >= 1" if align < 1
        address = (address + align - 1) / align * align + offset.to_i
        raise Syntax, "The current code pointer: #{pc.to_s 16} is exceeding: #{address.to_i.to_s 16} " if pc > address
        raise Syntax, "The current code pointer is exceeding 64k address range: #{address.to_i.to_s 16} " if address > 0x10000
        Z80::add_code self, [pad].pack('c')*(address - pc)
end

# File lib/z80.rb, line 293
def pc
        @code.bytesize
end

# File lib/z80/labels.rb, line 127
def pointer?(arg)
        if arg.is_a?(Array)
                true
        elsif arg.respond_to?(:pointer?)
                arg.pointer?
        elsif label?(arg)
                arg.to_label(self).pointer?
        else
                false
        end
end

# File lib/z80/labels.rb, line 101
def register?(arg)
        arg = arg.first while arg.is_a?(Array)
        arg.is_a?(Register)
end

# File lib/z80/select.rb, line 176
def select(*args, &test)
        ConditionalBlock.new(self, *args, &test).tap {|cndblk| @conditional_blocks << cndblk }
end

# File lib/z80/labels.rb, line 287
def union(label, type, align: nil, offset: 0)
        unless label.respond_to?(:to_label) and !label.sublabel? and !label.dummy? and !type.nil?
                raise Syntax, "Invalid union argument."
        end
        lbl = Label.new label.to_i, type, label.immediate? ? nil : :code
        if align
                align = align.to_i
                raise ArgumentError, "align must be >= 1" if align < 1
                lbl = (lbl + align - 1) / align * align
        end
        lbl = lbl + offset unless offset == 0
        lbl
end

# File lib/z80/labels.rb, line 83
def unwrap_pointer(arg)
        if arg.is_a?(Array)
                self.[](arg)
        else
                arg
        end
end

# File lib/z80/labels.rb, line 439
def words(*args); data(2, *args); end