4cd5aec · elk · git.iko.soy

git.iko.soy/elk

on master help sign in

Add generic way to handle conditional dev/prod kernel code

4cd5aecEvan Czaplicki9 years ago

src/AST/Kernel.hs+9

compare with master

unifiedsplit

@@ -28,6 +28,7 @@ data Info =

28data Chunk

29 = JS BS.ByteString

30 | Var ModuleName.Raw Text.Text

31+ | Prod Bool

@@ -51,9 +52,17 @@ instance Binary Chunk where

51 Var home name ->

52 Var home name ->

52 putWord8 1 >> put home >> put name

53 putWord8 1 >> put home >> put name

55+ Prod True ->

56+ putWord8 2

57+

58+ Prod False ->

59+ putWord8 3

60+

54 get =

61 get =

55 do word <- getWord8

62 do word <- getWord8

56 case word of

63 case word of

57 0 -> liftM JS get

64 0 -> liftM JS get

58 1 -> liftM2 Var get get

65 1 -> liftM2 Var get get

66+ 2 -> return (Prod True)

67+ 3 -> return (Prod False)

59 _ -> error "problem deserializing Parse.Kernel.Chunk"

68 _ -> error "problem deserializing Parse.Kernel.Chunk"

src/Generate/JavaScript.hs+7

@@ -156,6 +156,13 @@ chunkToBuilder builder chunk =

156 do expr <- JS.global (Var.Global (ModuleName.inCore home) name)

157 return $ JsBuilder.exprToBuilder expr <> builder

158

159+ Kernel.Prod isProd ->

160+ if isProd then

161+ return "_UNUSED"

162+ else

163+ return ""

164+

165+

159

166

160-- CRAWL HELPERS

167-- CRAWL HELPERS

161

168

src/Parse/Kernel.hs+21−16

@@ -43,25 +43,30 @@ type Enums =

44parserHelp :: Table -> Enums -> [Kernel.Chunk] -> Parser [Kernel.Chunk]

45parserHelp table enums chunks =

46− do (javascript, maybeMore) <- Parse.kernelChunk

46+ do (javascript, maybeTag) <- Parse.kernelChunk

47− case maybeMore of

47+ case maybeTag of

48 Nothing ->

49 return (Kernel.JS javascript : chunks)

51+ Just tag ->

52+ case tag of

53+ Parse.KernelProd isProd ->

54+ parserHelp table enums (Kernel.Prod isProd : Kernel.JS javascript : chunks)

55+

51− Just (Parse.KernelImport, var) ->

56+ Parse.KernelImport var ->

52− case Map.lookup var table of

57+ case Map.lookup var table of

53− Nothing ->

58+ Nothing ->

54− error $ show $ "could not find " <> var <> " when parsing kernel code"

59+ error $ show $ "could not find " <> var <> " when parsing kernel code"

55−

60+

56− Just (home, name) ->

61+ Just (home, name) ->

57− parserHelp table enums (Kernel.Var home name : Kernel.JS javascript : chunks)

62+ parserHelp table enums (Kernel.Var home name : Kernel.JS javascript : chunks)

58−

63+

59− Just (Parse.KernelEnum n, var) ->

64+ Parse.KernelEnum n var ->

60− let

65+ let

61− (bytes, newEnums) =

66+ (bytes, newEnums) =

62− lookupEnum n var enums

67+ lookupEnum n var enums

63− in

68+ in

64− parserHelp table newEnums (Kernel.JS bytes : Kernel.JS javascript : chunks)

69+ parserHelp table newEnums (Kernel.JS bytes : Kernel.JS javascript : chunks)

67lookupEnum :: Word8 -> Text -> Enums -> (BS.ByteString, Enums)

72lookupEnum :: Word8 -> Text -> Enums -> (BS.ByteString, Enums)

src/Parse/Primitives.hs+43−39

@@ -1307,66 +1307,70 @@ eatShader array offset length row col =

1307-- KERNEL CHOMP

1308

1309

1310+data ChunkTag

1310−data ChunkTag = KernelEnum Word8 | KernelImport

1311+ = KernelEnum Word8 Text

1312+ | KernelProd Bool

1313+ | KernelImport Text

1311

1314

1312

1315

1313−kernelChunk :: Parser (BS.ByteString, Maybe (ChunkTag, Text))

1316+kernelChunk :: Parser (BS.ByteString, Maybe ChunkTag)

1314kernelChunk =

1317kernelChunk =

1315 Parser $ \(State array offset length indent row col ctx) cok _ _ _ ->

1318 Parser $ \(State array offset length indent row col ctx) cok _ _ _ ->

1316 let

1319 let

1317− (# maybeChunkTag, newOffset, newLength, newRow, newCol #) =

1320+ (# maybeChunkTag, jsOffset, newOffset, newLength, newRow, newCol #) =

1318− kernelChunkHelp array offset length row col

1321+ chompChunk array offset length row col

1319

1322

1320− javascript =

1323+ !javascript =

1321− Text.encodeUtf8 (Text.Text array offset (newOffset - offset))

1324+ Text.encodeUtf8 (Text.Text array offset (jsOffset - offset))

1322− in

1323− case maybeChunkTag of

1324− Nothing ->

1325− let

1326− !newState =

1327− State array newOffset newLength indent newRow newCol ctx

1328− in

1329− cok (javascript, Nothing) newState noError

1330−

1331− Just tag ->

1332− let

1333− (# newerOffset, newerLength, newerCol #) =

1334− varPrimHelp array newOffset newLength newCol

1335

1325

1336− !newState =

1326+ !newState =

1337− State array newerOffset newerLength indent newRow newerCol ctx

1327+ State array newOffset newLength indent newRow newCol ctx

1338−

1339− !kernelSymbol =

1340− Text.Text array newOffset (newerOffset - newOffset)

1341− in

1328+ in

1342− cok (javascript, Just (tag, kernelSymbol)) newState noError

1329+ cok (javascript, maybeChunkTag) newState noError

1343

1330

1344

1331

1345−kernelChunkHelp :: Text.Array -> Int -> Int -> Int -> Int -> (# Maybe ChunkTag, Int, Int, Int, Int #)

1332+chompChunk :: Text.Array -> Int -> Int -> Int -> Int -> (# Maybe ChunkTag, Int, Int, Int, Int, Int #)

1346−kernelChunkHelp array offset length row col =

1333+chompChunk array offset length row col =

1347 if length == 0 then

1334 if length == 0 then

1348− (# Nothing, offset, length, row, col #)

1335+ (# Nothing, offset, offset, length, row, col #)

1349

1336

1350 else

1337 else

1351 let

1338 let

1352 !word = Text.unsafeIndex array offset

1339 !word = Text.unsafeIndex array offset

1353 in

1340 in

1354 if word == 0x005F {- _ -} && length > 3 && Text.unsafeIndex array (offset + 1) == 0x005F {- _ -} then

1341 if word == 0x005F {- _ -} && length > 3 && Text.unsafeIndex array (offset + 1) == 0x005F {- _ -} then

1355− (# Just (toChunkTag (Text.unsafeIndex array (offset + 2))), offset, length, row, col #)

1342+ chompChunkTag array offset (offset + 2) (length - 2) row (col + 2)

1356

1343

1357 else if word == 0x000A {- \n -} then

1344 else if word == 0x000A {- \n -} then

1358− kernelChunkHelp array (offset + 1) (length - 1) (row + 1) 1

1345+ chompChunk array (offset + 1) (length - 1) (row + 1) 1

1359

1346

1360 else if word < 0xD800 || word > 0xDBFF then

1347 else if word < 0xD800 || word > 0xDBFF then

1361− kernelChunkHelp array (offset + 1) (length - 1) row (col + 1)

1348+ chompChunk array (offset + 1) (length - 1) row (col + 1)

1362

1349

1363 else

1350 else

1364− kernelChunkHelp array (offset + 2) (length - 2) row (col + 1)

1351+ chompChunk array (offset + 2) (length - 2) row (col + 1)

1365

1352

1366

1353

1367−toChunkTag :: Word16 -> ChunkTag

1354+chompChunkTag :: Text.Array -> Int -> Int -> Int -> Int -> Int -> (# Maybe ChunkTag, Int, Int, Int, Int, Int #)

1355+chompChunkTag array jsOffset offset length row col =

1356+ let

1357+ (# newOffset, newLength, newCol #) =

1358+ varPrimHelp array offset length col

1359+

1368−toChunkTag word =

1360+ !word =

1361+ Text.unsafeIndex array offset

1362+

1363+ !kernelSymbol =

1364+ Text.Text array offset (newOffset - offset)

1365+

1366+ !chunkTag =

1369− if isDigit word then

1367+ if isDigit word then

1370− KernelEnum (fromIntegral (word - 0x0030 {- 0 -}))

1368+ KernelEnum (fromIntegral (word - 0x0030 {- 0 -})) kernelSymbol

1369+ else if kernelSymbol == "DEV" then

1370+ KernelProd False

1371+ else if kernelSymbol == "PROD" then

1372+ KernelProd True

1371− else

1373+ else

1372− KernelImport

1374+ KernelImport kernelSymbol

1375+ in

1376+ (# Just chunkTag, jsOffset, newOffset, newLength, row, newCol #)