wip parseCodeGeneratorRequestComplete

cd schema/

shopt -s globstar

time protoc --purescript_out=./_generated ./**/*.proto

Author: jamesdbrock

plugin/src/Main.purs

@@ -5,14 +5,17 @@ module Main (main) where
 
 import Prelude
 
-import Control.Monad.Rec.Class (tailRecM, Step(..))
+import Control.Monad.Rec.Class (class MonadRec, Step(..), tailRecM)
+import Control.Monad.Trans.Class (lift)
 import Data.Array (catMaybes, concat, fold, mapWithIndex)
 import Data.Array as Array
 import Data.ArrayBuffer.ArrayBuffer as AB
 import Data.ArrayBuffer.Builder (execPutM)
 import Data.ArrayBuffer.DataView as DV
+import Data.ArrayBuffer.Types as ABT
 import Data.CodePoint.Unicode as Unicode
 import Data.Either (Either(..), either)
+import Data.List as List
 import Data.Maybe (Maybe(..), fromMaybe, maybe)
 import Data.Newtype (unwrap)
 import Data.String (Pattern(..))
@@ -22,11 +25,12 @@ import Data.String.Regex as String.Regex
 import Data.String.Regex.Flags as String.Regex.Flags
 import Data.Traversable (sequence, traverse)
 import Data.Tuple (Tuple(..))
+import Data.UInt as UInt
 import Data.UInt64 (UInt64)
 import Data.UInt64 as UInt64
 import Effect (Effect)
 import Effect.Aff (runAff_, throwError, error)
-import Effect.Class (liftEffect)
+import Effect.Class (class MonadEffect, liftEffect)
 import Effect.Class.Console as Console
 import Google.Protobuf.Compiler.Plugin (CodeGeneratorRequest(..), CodeGeneratorResponse, CodeGeneratorResponse_File(..), mkCodeGeneratorResponse, parseCodeGeneratorRequest, putCodeGeneratorResponse)
 import Google.Protobuf.Descriptor (DescriptorProto(..), EnumDescriptorProto(..), EnumValueDescriptorProto(..), FieldDescriptorProto(..), FieldDescriptorProto_Label(..), FieldDescriptorProto_Type(..), FieldOptions(..), FileDescriptorProto(..), OneofDescriptorProto(..), SourceCodeInfo(..), SourceCodeInfo_Location(..))
@@ -35,7 +39,13 @@ import Node.Buffer as Buffer
 import Node.Path (basenameWithoutExt)
 import Node.Process (stdin, stdout)
 import Node.Stream.Aff (readSome, write)
-import Parsing (runParserT)
+import Parsing (ParserT, fail, runParserT)
+import Parsing.Combinators (try, many)
+import Parsing.DataView (takeN)
+import Partial.Unsafe (unsafePartial)
+import Protobuf.Internal.Common (label)
+import Protobuf.Internal.Decode (decodeString, decodeTag32)
+import Protobuf.Internal.Runtime (parseLenDel)
 import Unsafe.Coerce (unsafeCoerce)
 
 
@@ -51,12 +61,15 @@ main = runAff_ (either (unsafeCoerce >>> Console.error) (\_ -> pure unit)) do
     {buffers:b,readagain} <- readSome stdin
     let bs' = bs <> b
     ab <- liftEffect $ toArrayBuffer =<< Buffer.concat bs'
-    runParserT (DV.whole ab) (parseCodeGeneratorRequest (AB.byteLength ab)) >>= case _ of
+    bsize <- unsafePartial $ liftEffect $ Buffer.size $ Array.unsafeIndex b 0
+    Console.error $ "read " <> show bsize <> " to " <> show (AB.byteLength ab)
+    runParserT (DV.whole ab) (parseCodeGeneratorRequestComplete (AB.byteLength ab)) >>= case _ of
       Left err -> do
         if not readagain then do
           void $ throwError $ error "stdin is not readable."
           pure (Done unit)
         else if (Array.length bs') < 10000 then do
+          Console.error $ show err
           -- What we want to do here is detect whether this parsing error was
           -- because we read to the end of the buffer and need to read more.
           -- But we don't have a good way to do that right now, so we assume
@@ -68,11 +81,82 @@ main = runAff_ (either (unsafeCoerce >>> Console.error) (\_ -> pure unit)) do
         else do
           void $ throwError $ error $ show err
           pure (Done unit)
-      Right request -> do
-        responseBuf <- execPutM $ putCodeGeneratorResponse (generate request)
-        buf :: Buffer <- liftEffect $ fromArrayBuffer responseBuf
-        write stdout [buf]
-        pure (Done unit)
+      Right unit -> do
+        runParserT (DV.whole ab) (parseCodeGeneratorRequest (AB.byteLength ab)) >>= case _ of
+          Left err -> do
+            void $ throwError $ error $ show err
+            pure (Done unit)
+          Right request -> do
+            Console.error $ "parsed request, generating response"
+            responseBuf <- execPutM $ putCodeGeneratorResponse (generate request)
+            buf :: Buffer <- liftEffect $ fromArrayBuffer responseBuf
+            write stdout [buf]
+            pure (Done unit)
+
+-- | This is a parser which will succeed only if parseCodeGeneratorRequest will succeed.
+-- | It is faster than parseCodeGeneratorRequest.
+-- | It uses extra assumptions about the order of the CodeGeneratorRequest fields.
+-- -- | Returns True if parseCodeGeneratorRequest will succeed.
+-- -- | Returns False if parseCodeGeneratorRequest might succeed with more input.
+parseCodeGeneratorRequestComplete
+  :: forall m. MonadEffect m
+  => MonadRec m
+  => ABT.ByteLength
+  -> ParserT ABT.DataView m Unit
+parseCodeGeneratorRequestComplete length = label "parseCodeGeneratorRequestComplete / " $ do
+
+  files_to_generate <- label "file_to_generate / " $ many $ try $ do
+    Tuple fieldNumber wireType <- decodeTag32
+    if fieldNumber == UInt.fromInt 1 then do decodeString else fail (show fieldNumber)
+    -- lift $ Console.error $ "files_to_generate " <> s
+
+  if List.length files_to_generate == 0 then do fail "No files_to_generate" else pure unit
+
+  _ <- label "compiler_version / " $ do
+    Tuple fieldNumber wireType <- decodeTag32
+    if fieldNumber == UInt.fromInt 3 then do parseLenDel takeN else fail (show fieldNumber)
+
+  _ <- label "parameter / " $ do
+    Tuple fieldNumber wireType <- decodeTag32
+    if fieldNumber == UInt.fromInt 2 then do decodeString else fail (show fieldNumber)
+
+  proto_files <- label "proto_file / " $ many $ try $ do
+    Tuple fieldNumber wireType <- decodeTag32
+    if fieldNumber == UInt.fromInt 15 then do parseLenDel takeN else fail (show fieldNumber)
+
+  if List.length proto_files == 0 then do fail "No proto_files" else pure unit
+
+  source_file_descriptors <- label "source_file_descriptors / " $ many $ try $ do
+    Tuple fieldNumber wireType <- decodeTag32
+    if fieldNumber == UInt.fromInt 17 then do parseLenDel takeN else fail (show fieldNumber)
+
+  -- if Array.length source_file_descriptors == 0 then do fail "No source_file_descriptors" else pure unit
+
+  pure unit
+
+--    Prelude.parseMessage CodeGeneratorRequest defaultCodeGeneratorRequest parseField length
+--   where
+--    parseField
+--      :: Prelude.FieldNumberInt
+--      -> Prelude.WireType
+--      -> Prelude.ParserT Prelude.DataView m (Prelude.Builder CodeGeneratorRequestR CodeGeneratorRequestR)
+--    parseField 1 Prelude.LenDel = Prelude.label "file_to_generate / " $ do
+--      x <- Prelude.decodeString
+--      pure $ Prelude.modify (Prelude.Proxy :: Prelude.Proxy "file_to_generate") $ Prelude.flip Prelude.snoc x
+--    parseField 2 Prelude.LenDel = Prelude.label "parameter / " $ do
+--      x <- Prelude.decodeString
+--      pure $ Prelude.modify (Prelude.Proxy :: Prelude.Proxy "parameter") $ \_ -> Prelude.Just x
+--    parseField 15 Prelude.LenDel = Prelude.label "proto_file / " $ do
+--      x <- Prelude.parseLenDel Google.Protobuf.parseFileDescriptorProto
+--      pure $ Prelude.modify (Prelude.Proxy :: Prelude.Proxy "proto_file") $ Prelude.flip Prelude.snoc x
+--    parseField 17 Prelude.LenDel = Prelude.label "source_file_descriptors / " $ do
+--      x <- Prelude.parseLenDel Google.Protobuf.parseFileDescriptorProto
+--      pure $ Prelude.modify (Prelude.Proxy :: Prelude.Proxy "source_file_descriptors") $ Prelude.flip Prelude.snoc x
+--    parseField 3 Prelude.LenDel = Prelude.label "compiler_version / " $ do
+--      x <- Prelude.parseLenDel parseVersion
+--      pure $ Prelude.modify (Prelude.Proxy :: Prelude.Proxy "compiler_version") $ Prelude.Just Prelude.<<< Prelude.maybe x (mergeVersion x)
+--    parseField fieldNumber wireType = Prelude.parseFieldUnknown fieldNumber wireType
+
 
 generate :: CodeGeneratorRequest -> CodeGeneratorResponse
 generate (CodeGeneratorRequest { proto_file }) = do