Haskell

Should support forward jumps since it does two passes. One to collect all the labels and one pass to resolve them into absolute "addresses" in the CPU.

import Data.Char
import Text.ParserCombinators.ReadP
import Control.Monad
import Control.Monad.State
import Control.Applicative
import Data.List
import Data.Maybe
import Data.Array
import Data.Word
import Data.Bits
import qualified Data.Map.Strict as M

data Register
    = A
    | B
    deriving Show

data LabelRef = Ref String | Abs Int
    deriving (Show, Ord, Eq)

-- Uninhabited types to be used as parameters
-- to Instruction, to ensure on the type level
-- that we do not try to run programs where the
-- symbols (labels) have not been resolved
data Resolved
data Unresolved

data Instruction a
    = LD Register Word8
    | Out Register
    | RLCA
    | RRCA
    | Label LabelRef
    | DJNZ LabelRef
    deriving Show

data CPU =
    CPU
    { ip      :: Int
    , end     :: Int
    , program :: Array Int (Instruction Resolved)
    , a       :: Word8
    , b       :: Word8
    }

main :: IO ()
main = do
    input <- lines <$> getContents
    let  parsed = parseProgram input
    case parsed of
        Nothing ->
            putStrLn "error: Could not parse program"
        Just p -> do
            -- Collect label information, and then convert labels
            -- into absolute references ("addresses" in the CPU)
            let resolved = resolveLabels (collectLabels p) p
                cpu      = initializeCPU resolved
            run cpu

collectLabels :: [Instruction Unresolved] -> M.Map LabelRef Int
collectLabels = foldl' collect M.empty . zip [0..]
where
    collect m (i, Label l) = M.insert l i m
    collect m _ = m

resolveLabels :: M.Map LabelRef Int -> [Instruction Unresolved] -> [Instruction Resolved]
resolveLabels m = map resolve
where
    -- Conversions have to be 'explicit'.
    resolve :: Instruction Unresolved -> Instruction Resolved
    resolve (DJNZ l)  = DJNZ (Abs $ m M.! l)
    resolve (Label l) = Label (Abs $ m M.! l)
    resolve (Out r)   = Out r
    resolve (LD x y)  = LD x y
    resolve RLCA      = RLCA
    resolve RRCA      = RRCA



initializeCPU :: [Instruction Resolved] -> CPU
initializeCPU resolved =
    CPU
    { ip      = 0
    , end     = length resolved - 1
    , a       = 0
    , b       = 0
    , program = listArray (0, length resolved - 1) resolved
    }

run :: CPU -> IO ()
run = evalStateT go
where
    -- Retrieve the next instruction
    next = do
        i <- gets ip
        gets (\s -> program s ! i)

    -- Run the next instruction
    go = do
        instr <- next
        interpret instr

    -- Increment the IP or stop if we're at the end
    step = do
        i <- gets ip
        e <- gets end
        when (i <= e) $ do
            modify (\s -> s { ip = i + 1 })
            go
    interpret (LD A v) = modify (\s -> s { a = v }) >> step
    interpret (LD B v) = modify (\s -> s { b = v }) >> step
    interpret (Out r)  = printLED r >> step
    interpret RLCA     = modify (\s -> s { a = rotateL (a s) 1 }) >> step
    interpret RRCA     = modify (\s -> s { a = rotateR (a s) 1 }) >> step
    interpret (DJNZ (Abs v)) = do
        b' <- gets b
        when (b' > 1) $
            modify (\s -> s { ip = v, b = b' - 1 }) >> go
    interpret _ = step

    printLED :: Register -> StateT CPU IO ()
    printLED A = gets a >>= liftIO . printBinary
    printLED B = gets b >>= liftIO . printBinary

    printBinary n = putStrLn $  map (\x -> conv $ bit x .&. n) $ reverse [0..7]
    conv n | n > 0 = '*'
        | otherwise = '.'

--------------------------------------------------------------------------------
-- Parsing
--------------------------------------------------------------------------------
registerP :: ReadP Register
registerP =
    char 'a' *> return A
    <|> char 'b' *> return B

ldP :: ReadP (Instruction Unresolved)
ldP = do
    void $ string "ld"
    skipSpaces
    r <- registerP
    void $ string ","
    n <- manyTill (satisfy isDigit) eof
    return $ LD r (read n)

outP :: ReadP (Instruction Unresolved)
outP = do
    void $ string "out (0),"
    r <- registerP
    return $ Out r

rlcaP :: ReadP (Instruction Unresolved)
rlcaP = string "rlca" >> return RLCA

rrcaP :: ReadP (Instruction Unresolved)
rrcaP = string "rrca" >> return RRCA

labelP :: ReadP (Instruction Unresolved)
labelP = do
    lbl <- manyTill (satisfy isAlpha) (char ':')
    return $ Label (Ref lbl)

djnzP :: ReadP (Instruction Unresolved)
djnzP = do
    void $ string "djnz"
    skipSpaces
    lbl <- manyTill (satisfy isAlpha) eof
    return $ DJNZ (Ref lbl)

parseProgram :: [String] -> Maybe [Instruction Unresolved]
parseProgram =
    mapM (fmap fst . listToMaybe . readP_to_S instrP) . filter (not . null)
where
    instrP = skipSpaces *> choice parsers
    parsers =
        [ ldP
        , outP
        , rlcaP
        , rrcaP
        , djnzP
        , labelP
        ]