-- as for deep thoughts ISA
-----------------------------------------------------------------------------
-
-module Main where
-
import DT
import DTFormat
+import Expr_eval
import Control.Applicative hiding ((<|>),many)
args <- getArgs
content <- getContents
let src = (filter (((/=) "") . snd) $ (zip [1..] (lines content)))
- let (dict,formatedsrc) = convertDTF src NoState 0x00 0x00 []
+ let (dict,formatedsrc) = convertDTF src NoState 0x00 0x00 [("start_",0x00)]
printf "\nlabels:\n"
- sequence_ [printf "%10s @ 0x%08x\n" l a | (l,a) <- (reverse dict)]
+ sequence_ [printf "%20s @ 0x%08x\n" l a | (l,a) <- (reverse dict)]
printf "\nparsed asm:\n"
sequence_ [printf "%s" (show x) | x <- formatedsrc]
+ let parsed = parseInstr dict formatedsrc
+ printf "\nafter parsing the instructions:\n"
+ sequence_ [printf "%s" (show x) | x <- parsed]
+
+
+parseInstr :: [DictElem] -> [DTF] -> [DTF]
+parseInstr _ [] = []
+parseInstr dict ((DTF_InstrToParse a instr c l s):xs) =
+ (DTF_Instr a bytecode c l s):(parseInstr dict xs)
+ where
+ bytecode = case (parse (instruction (a,dict)) "" (instr++"\n")) of
+ Left err -> error ("couldn't parse Instruction: " ++ instr ++ "\n" ++ show err)
+ Right x -> x
+parseInstr dict (x:xs) = x:(parseInstr dict xs)
type Counter = Word32
inc = ((+) 4)
-type DictLabel = (String,Word32)
-
-get_label :: String -> [DictLabel] -> Maybe Word32
-get_label = lookup
-
-add_label :: [DictLabel] -> (String,Word32) -> [DictLabel]
-add_label dic (s,w)
- | s == "" = dic -- ignore empty string
- | already_in = error ("Label " ++ s ++ " already exists")
- | otherwise = (s,w):dic
- where
- already_in = case (get_label s dic) of
- Just _ -> True
- Nothing -> False
-
-
-convertDTF :: [(Int,String)] -> DT_State -> Counter -> Counter -> [DictLabel] -> ([DictLabel], [DTF])
+convertDTF :: [(Int,String)] -> DT_State -> Counter -> Counter -> [DictElem] -> ([DictElem], [DTF])
convertDTF [] _ _ _ d = (d,[])
convertDTF ((lno,str):xs) state datacnt instrcnt dict = (newdict, (actlist newdtf))
where
actlist (DTF_Org _) = next
actlist (DTF_State _) = next
+ actlist (DTF_Define _ _ _) = next
actlist y = y:next
(newdict,next) = convertDTF xs (nstate newdtf) (ndatacnt newdtf) (ninstrcnt newdtf) (ndict newdtf)
nstate (DTF_State s) = s
nstate _ = state
- ndict (DTF_Label l _ a) = dict `add_label` (l,a)
- ndict (DTF_SectionToDet a _ _ l _) = dict `add_label` (l,a)
- ndict (DTF_InstrToParse a _ _ l _) = dict `add_label` (l,a)
- ndict (DTF_Data a _ _ l _) = dict `add_label` (l,a)
- ndict (DTF_Instr a _ _ l _) = dict `add_label` (l,a)
+ ndict (DTF_Label l _ a) = dict `add_elem` (l,a)
+ ndict (DTF_SectionToDet a _ _ l _) = dict `add_elem` (l,a)
+ ndict (DTF_InstrToParse a _ _ l _) = dict `add_elem` (l,a)
+ 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 _ = dict
- newdtf = case (parse parseDTFLine "" (str++"\n")) of
+ newdtf = case (parse (parseDTFLine dict) "" (str++"\n")) of
Left err -> error ("couldn't parse line " ++ (show lno) ++ ": " ++ (show err))
Right (DTF_SectionToDet _ v c l s) ->
case state 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
+ Right z -> z -- DTF_Comment, DTF_State, DTF_Define
testDTF :: String -> IO ()
testDTF input =
- case (parse parseDTFLine "" (input++"\n")) of
+ case (parse (parseDTFLine dict) "" (input++"\n")) of
Left err -> do { putStr "failz ;(\n"; print err}
Right x -> do { print x }
+ where
+ dict = [("lolz", 0x1337), ("rofl", 0xaaaa)]
-parseDTFLine :: Parser DTF
-parseDTFLine = foldl1 (<|>) (fmap try lineFormats) <* char '\n'
+parseDTFLine :: [DictElem] -> Parser DTF
+parseDTFLine dict = foldl1 (<|>) (fmap (\x -> try (x dict)) lineFormats) <* char '\n'
-lineFormats = [lf_sdata, lf_stext, lf_org, lf_data, lf_comment, lf_toparse, lf_label]
+lineFormats = [lf_define, lf_sdata, lf_stext, lf_org, lf_data, lf_comment, lf_toparse, lf_label]
-- helper
+parseIdent :: Parser String
+parseIdent = do
+ ident <- letter
+ idents <- many $ (letter <|> digit <|> char '_')
+ return $ (ident:idents)
+
parseLabel :: Parser String
parseLabel = do
- label <- letter
- labels <- many $ (letter <|> digit <|> char '_')
+ l <- parseIdent
char ':'
- return $ (label:labels)
+ return $ l
parseComment :: Parser String
parseComment = do
comment <- many $ noneOf "\n"
return $ comment
-parseConst :: Parser Word32
-parseConst = do
- skipMany space
- -- TODO: only decimal and hex (since this is supported by read)
- -- TODO: howto check too big values? atm they get truncated
- str <- try(do pref <- string "0x"; z <- many1 hexDigit; return $ (pref ++ z)) <|> (many1 digit)
- let val = read str
- return $ val
-
-parseMySpaces :: Parser String
-parseMySpaces = do
- ret <- many $ oneOf "\t "
- return $ ret
+parseConst :: [DictElem] -> Parser Word32
+parseConst d = expr d
-- teh pars0rs
-lf_data = do
+lf_data d = do
l <- try (parseLabel) <|> string ""
skipMany space
fill <- string ".fill "
-- TODO: atm 32bit imm only
code <- many1 $ noneOf "\n;"
-- TODO: this is quite ugly here :/
- let (Right val) = parse parseConst "" code
+ let (Right val) = parse (parseConst d) "" code
comment <- try(parseComment) <|> parseMySpaces
return $ DTF_SectionToDet 0 val (fill ++ code) l comment
-lf_comment = do
+lf_comment _ = do
comment <- parseComment
return $ DTF_Comment comment
-lf_label = do
+lf_label _ = do
l <- parseLabel
comment <- try(parseComment) <|> parseMySpaces
return $ DTF_Label l comment 0
-lf_toparse = do
+lf_toparse _ = do
l <- try(parseLabel) <|> string ""
skipMany space
code <- many1 $ noneOf "\n;"
comment <- try(parseComment) <|> parseMySpaces
return $ DTF_InstrToParse 0 code code l comment
-lf_org = do
+lf_org d = do
skipMany space
string ".org"
- val <- parseConst
+ val <- parseConst d
parseMySpaces
return $ DTF_Org val
-lf_sdata = do
+lf_sdata _ = do
skipMany space
string ".data"
parseMySpaces
return $ DTF_State InData
-lf_stext = do
+lf_stext _ = do
skipMany space
string ".text"
parseMySpaces
return $ DTF_State InText
+
+lf_define d = do
+ skipMany space
+ string ".define"
+ parseMySpaces
+ id <- parseIdent
+ char ','
+ -- TODO: expressions with (expr) do not work ;(
+ ret <- parseConst d
+ comment <- try(parseComment) <|> parseMySpaces
+ return $ DTF_Define id ret comment