address in data or instruction memory, depending on the current
section \\ \hline
- \texttt{.fill \textit{repeat}, \textit{size}, \textit{value}} & place a
- value of a specific size \texttt{\textit{repeat}}-times, while
- \texttt{\textit{repeat}} and \texttt{\texttt{size}} are optional.
+ \texttt{.fill \textit{repeat}, \textit{value}} & place a
+ 32 bit value \texttt{\textit{repeat}}-times, while
+ \texttt{\textit{repeat}} is optional.
When one parameter is given, the value is placed at the current address.
Note that a given value will be rounded up to a full byte, e.g.
type Address = Word32
type Value = Word32
+type Repeat = Word32
type ValueToParse = String
type Code = String
type Label = String
DTF_SectionToDet Address Value Code Label Comment |
DTF_Org Address |
DTF_Define Label Value Comment |
+ DTF_Fill Repeat Value Label Code Comment |
DTF_State DT_State
instance Show (DTF) where
showsDTF (DTF_InstrToParse a v c l s) = (++) (printf "itp;%08x;%s;%s;%s;%s\n" a v c l s)
showsDTF (DTF_SectionToDet a v c l s) = (++) (datins "std" a v c l s)
showsDTF (DTF_Org a) = (++) (printf "org;%08x\n" a)
-showsDTF (DTF_Define l a c) = (++) (printf "def;%s;%08X;%s\n" l a c)
+showsDTF (DTF_Define l a c) = (++) (printf "def;%s;%08x;%s\n" l a c)
+showsDTF (DTF_Fill r v code l c) = (++) (printf "fill;%08x;%08x;%s;%s;%s\n" r v code l c)
showsDTF (DTF_State s) = (++) (printf "sta;%s\n" (show s))
datins :: String -> Address -> Value -> Code -> Label -> Comment -> String
actlist (DTF_Org _) = next
actlist (DTF_State _) = next
actlist (DTF_Define _ _ _) = next
+ actlist (DTF_Fill rep val code l c) = if state == InData then
+ (DTF_Data datacnt val code l c):[(DTF_Data dc val "" "" "") | i<-[2..repi], let dc = [(datacnt+0x4),(datacnt+0x8)..]!!(i-2)] ++ next
+ else
+ (DTF_Instr instrcnt val code l c):[(DTF_Instr ic val "" "" "") | i<-[2..repi], let ic = [(instrcnt+0x4),(instrcnt+0x8)..]!!(i-2)] ++ next
+ where
+ repi :: Int
+ repi = fromInteger (toInteger rep)
actlist y = y:next
(newdict,next) = convertDTF xs (nstate newdtf) (ndatacnt newdtf) (ninstrcnt newdtf) (ndict newdtf)
ndatacnt (DTF_Org adr)
| state == InData = adr
| otherwise = datacnt
+ ndatacnt (DTF_Fill rep _ _ _ _)
+ | state == InData = datacnt + (4*rep)
+ | otherwise = datacnt
ndatacnt (DTF_Data _ _ _ _ _) = inc datacnt
ndatacnt _ = datacnt
ninstrcnt (DTF_Org adr)
| state == InText = adr
| otherwise = instrcnt
+ ninstrcnt (DTF_Fill rep _ _ _ _)
+ | state == InText = instrcnt + (4*rep)
+ | otherwise = instrcnt
ninstrcnt (DTF_Instr _ _ _ _ _) = inc instrcnt
ninstrcnt (DTF_InstrToParse _ _ _ _ _) = inc instrcnt
ninstrcnt _ = instrcnt
ndict (DTF_Data a _ _ l _) = dict `add_elem` (l,a)
ndict (DTF_Instr a _ _ l _) = dict `add_elem` (l,a)
ndict (DTF_Define l v _) = dict `add_elem` (l,v)
+ ndict (DTF_Fill _ _ _ l _)
+ | state == InText = dict `add_elem` (l,instrcnt)
+ | state == InData = dict `add_elem` (l,datacnt)
ndict _ = dict
newdtf = case (parse (parseDTFLine dict) "" (str++"\n")) of
NoState -> error "missing .data or .text"
InData -> (DTF_Label l c datacnt)
InText -> (DTF_Label l c instrcnt)
- Right z -> z -- DTF_Comment, DTF_State, DTF_Define
+ Right z -> z -- DTF_Comment, DTF_State, DTF_Define, DTF_Fill
l <- try (parseLabel) <|> string ""
skipMany space
fill <- string ".fill "
+ repeat <- try (do {size <- many1 $ noneOf "\n;,"; char ','; return $ size}) <|> return "1"
-- TODO: atm 32bit imm only
code <- many1 $ noneOf "\n;"
-- TODO: this is quite ugly here :/
let (Right val) = parse (parseConst d) "" code
+ let (Right r) = parse (parseConst d) "" repeat
comment <- try(parseComment) <|> parseMySpaces
- return $ DTF_SectionToDet 0 val (fill ++ code) l comment
+ return $ DTF_Fill r val (fill ++ (if repeat == "1" then "" else repeat) ++ code) l comment
lf_comment _ = do
comment <- parseComment