npc-1.5.tar

npc-1.5/0000775000175000017500000000000012134602756010601 5ustar  nicknicknpc-1.5/README0000664000175000017500000000646512135057127011471 0ustar  nicknick+-------+
| BUILD |
+-------+

To re-compile, just run 'make'. You will need the Haskell platform.

+------------+
| INVOCATION |
+------------+

The tool may be invoked using either 'npc --all [--inc=FILE]' or
'npc [--inc=FILE] packet1 [packet2...]'. The --all flag (short option -a)
will run the tool on all files in the directory with a .packet extension.
The --inc=FILE flag (short option -iFILE) specifies the inclusion file for
user-defined classes (see USER CLASSES below). It is necessary if and only
if your packets contain user-defined classes.

Instead of using --all, you may invoke npc by explicitly naming the packets
you wish to compile.

Help on the npc command can be found by invoking npc with no arguments.

+--------+
| FORMAT |
+--------+

The format of packets is as follows:

packet <packet_name> {
  <C_type> <field_name>;
  ...
}

Standard C++ naming rules apply. <packet_name> may not be Packet. Empty
packets are allowed.

Packets in the same .packet file will be in the same .h/.cpp files.

+---------------+
| ALLOWED TYPES |
+---------------+

Support is built-in for all primitives, size_t, time_t, (C++) strings, vectors,
lists, and maps. No pointers or references are allowed. Types may be nested,
e.g. map<string, vector<int>>.
If <C_type> is a user-defined class, that class must define
        - unsigned int SerializedSize() const
        - void Serialize(ByteBuffer &) const
        - void Deserialize(ByteBuffer &)

+------------+
| USER TYPES |
+------------+

For user-defined types, you will need to specify an inclusions file that
tells npc which header files to include for those classes. This should be
specified with the --inc=FILE option. The file itself should look like

class_name1:header_file1;
class_name2:header_file2;
...

Each class you use must be specified in the inclusions file, or a "Map.find"
error will be thrown.

+----------+
| COMMENTS |
+----------+

Block comments (/* ... */) are allowed outside and only outside
packet definitions. Nesting block comments is NOT allowed.

Single-line comments (// ...) are allowed inside and only inside packet
definitions. Single line comments are also allowed in the inclusions file.

Allowed (packet files):

  /* This packet is for requests.
     I like requests. */
  packet Request {
    // Here are the fields
    int status; // OK
    //bool debug;
    string name;
  }

Not allowed (packet files):

  // The best response ever
  packet Response {
    /* I don't want these now
    bool save;
    string filename;
    */
    int number;
  }

Allowed (inclusions file):

  MyClass:myclass.h // awesome
  //Foo:foo.h

Not Allowed (inclusions file):

  MyClass:myclass.h
  /*
  Foo:foo.h
  Bar:bar.h
  */

+--------------+
| KNOWN ISSUES |
+--------------+

None.

+-----------+
| CHANGELOG |
+-----------+

Version 1.5:
Added TypeString method to Packet
Added virtual destructor to Packet, made ctor/dtor public
Added support for size_t and time_t

Version 1.4:
Added support for lists
Added sequence numbers

Version 1.3:
Added inclusions file.
Removed --main option.
Removed boolean err from Packet::DeserializePacket

Version 1.2:
Added more convenient deserialization
Reduced number of I/O operations
Fixed empty packet bug

Version 1.1:
Non-const accessors removed for primitives, since they're useless
Source file Npc.hs now has comments

Version 1.0:
Initial releasenpc-1.5/bytebuffer.cpp0000664000175000017500000000737112135054676013455 0ustar  nicknick#include "bytebuffer.h"

#include <cstdlib>
#include <ctime>
#include <string>
#include <vector>

#define BYTE 8

#define SERIALIZE2(TYPE, X)                             \
  for (unsigned int i = sizeof(TYPE); i > 0; i--)       \
    buffer.push_back((X >> ((i-1) * BYTE)) & 0xff)

#define DESERIALIZE2(TYPE, X)                           \
  TYPE X = *it++;                                       \
  for (unsigned int i = 1; i < sizeof(TYPE); i++)       \
    (X <<= BYTE) += (*it++)

#define SERIALIZE(TYPE, X)                                      \
  unsigned char *bytes = reinterpret_cast<unsigned char *>(&X); \
  for (unsigned int i = 0; i < sizeof(TYPE); i++)               \
    buffer.push_back(bytes[i])

#define DESERIALIZE(TYPE, X)                            \
  unsigned char bytes[sizeof(TYPE)];                    \
  for (unsigned int i = 0; i < sizeof(TYPE); i++)       \
    bytes[i] = *it++;                                   \
  TYPE *_ptr = reinterpret_cast<TYPE *>(bytes);         \
  TYPE X = *_ptr

ByteBuffer::ByteBuffer(char *serialized) {
  unsigned int s = sizeof(unsigned int);
  unsigned char bytes[sizeof(unsigned int)];
  for (unsigned int i = 0; i < s; i++)
    bytes[i] = serialized[i];
  unsigned int *size = reinterpret_cast<unsigned int *>(bytes);
  buffer.reserve(*size);
  for (unsigned int j = s; j < *size + s; j++)
    buffer.push_back(serialized[j]);
  it = buffer.begin();
}

char *ByteBuffer::Serialized() {
  unsigned int s = sizeof(unsigned int);
  unsigned int size = buffer.size();
  unsigned char *bytes = reinterpret_cast<unsigned char *>(&size);
  char *serialized = new char[buffer.size() + s];
  for (unsigned int i = 0; i < s; i++)
    serialized[i] = bytes[i];
  for (unsigned int j = 0; j < buffer.size(); j++)
    serialized[j + s] = buffer[j];
  return serialized;
}  

void ByteBuffer::SerializeBool(bool x) {
  buffer.push_back(x);
}

void ByteBuffer::SerializeChar(char x) {
  buffer.push_back(x);
}

void ByteBuffer::SerializeShort(short x) {
  SERIALIZE(short, x);
}

void ByteBuffer::SerializeInt(int x) {
  SERIALIZE(int, x);
}

void ByteBuffer::SerializeLong(long x) {
  SERIALIZE(long, x);
}

void ByteBuffer::SerializeLongLong(long long x) {
  SERIALIZE(long long, x);
}

void ByteBuffer::SerializeFloat(float x) {
  SERIALIZE(float, x);
}

void ByteBuffer::SerializeDouble(double x) {
  SERIALIZE(double, x);
}

void ByteBuffer::SerializeLongDouble(long double x) {
  SERIALIZE(long double, x);
}

void ByteBuffer::SerializeTime_t(time_t x) {
  SERIALIZE(time_t, x);
}

void ByteBuffer::SerializeSize_t(size_t x) {
  SERIALIZE(size_t, x);
}

void ByteBuffer::SerializeString(const std::string &str) {
  for (std::string::const_iterator i = str.begin();
       i != str.end(); ++i)
    buffer.push_back(*i);
  buffer.push_back('\0');
}

bool ByteBuffer::DeserializeBool() {
  return *it++ > 0;
}

char ByteBuffer::DeserializeChar() {
  return *it++;
}

short ByteBuffer::DeserializeShort() {
  DESERIALIZE(short, x);
  return x;
}

int ByteBuffer::DeserializeInt() {
  DESERIALIZE(int, x);
  return x;
}

long ByteBuffer::DeserializeLong() {
  DESERIALIZE(long, x);
  return x;
}

long long ByteBuffer::DeserializeLongLong() {
  DESERIALIZE(long long, x);
  return x;
}

float ByteBuffer::DeserializeFloat() {
  DESERIALIZE(float, x);
  return x;
}

double ByteBuffer::DeserializeDouble() {
  DESERIALIZE(double, x);
  return x;
}

long double ByteBuffer::DeserializeLongDouble() {
  DESERIALIZE(long double, x);
  return x;
}

time_t ByteBuffer::DeserializeTime_t() {
  DESERIALIZE(time_t, x);
  return x;
}

size_t ByteBuffer::DeserializeSize_t() {
  DESERIALIZE(size_t, x);
  return x;
}

std::string ByteBuffer::DeserializeString() {
  std::vector<unsigned char>::const_iterator first = it;
  while (*it != '\0')
    ++it;
  return std::string(first, it++);
}
npc-1.5/Makefile0000664000175000017500000000022612134602756012241 0ustar  nicknickOUT = npc

all: $(OUT)

$(OUT): Npc.hs PacketParser.hs
	ghc --make -O2 -o $(OUT) Npc.hs

clean:
	rm $(OUT) Npc.hi Npc.o PacketParser.hi PacketParser.onpc-1.5/bytebuffer.h0000664000175000017500000000326612135054676013121 0ustar  nicknick#ifndef __BYTE_BUFFER_HEADER__
#define __BYTE_BUFFER_HEADER__

#include <cstdlib>
#include <ctime>
#include <string>
#include <vector>

class ByteBuffer {
private:
  std::vector<unsigned char> buffer;
  std::vector<unsigned char>::const_iterator it;

public:
  ByteBuffer() : it(buffer.begin()) { }
  // Initial capacity in bytes
  ByteBuffer(int initialCapacity) {
    buffer.reserve(initialCapacity);
    it = buffer.begin();
  }
  // The input here must have been produced by ByteBuffer::Serialized()
  ByteBuffer(char *serialized);

  // Returned byte array must be deleted
  char *Serialized();
  // The size of the array returned by ByteBuffer::Serialized()
  unsigned int SerializedSize() { return buffer.size() + sizeof(unsigned int); }

  void SerializeBool(bool x);
  void SerializeChar(char x);
  void SerializeShort(short x);
  void SerializeInt(int x);
  void SerializeLong(long x);
  void SerializeLongLong(long long x);
  void SerializeFloat(float x);
  void SerializeDouble(double x);
  void SerializeLongDouble(long double x);
  void SerializeTime_t(time_t x);
  void SerializeSize_t(size_t x);
  void SerializeString(const std::string &str);

  // Must be called if any Serialize methods have been called
  // between the constructor and deserialization
  void StartDeserialize() { it = buffer.begin(); }

  bool DeserializeBool();
  char DeserializeChar();
  short DeserializeShort();
  int DeserializeInt();
  long DeserializeLong();
  long long DeserializeLongLong();
  float DeserializeFloat();
  double DeserializeDouble();
  long double DeserializeLongDouble();
  time_t DeserializeTime_t();
  size_t DeserializeSize_t();
  std::string DeserializeString();
};

#endif // __BYTE_BUFFER_HEADER__
npc-1.5/Npc.hs0000664000175000017500000004426612135057127011666 0ustar  nicknick{-# OPTIONS -Wall -fno-warn-name-shadowing #-}
{-# LANGUAGE FlexibleContexts #-}

import Control.Monad
import Control.Monad.Writer hiding (All)
import Data.Char
import Data.List
import Data.Map (Map)
import qualified Data.Map as M
import Data.Maybe (mapMaybe)
import Data.Set (Set)
import qualified Data.Set as S
import System.Console.GetOpt
import System.Directory
import System.Environment (getArgs)
import System.Exit
import System.FilePath.Posix

import PacketParser

type CppWriter = Writer String ()

{---------- Utility Functions ----------}

tellLn :: MonadWriter String m => String -> m ()
tellLn w = do
  tell w
  tell "\n"
  
lnBreak :: MonadWriter String m => m ()
lnBreak = tell "\n"

-- | Generates the comment given the file name
autoComment :: String -> String
autoComment f = "/* *** " ++ f ++ ": Auto-generated using npc *** */\n"

-- | Capitalizes a word
capitalize :: String -> String
capitalize "" = ""
capitalize (c:cs) = toUpper c : cs

-- | Determines what files need to be included for a type
has :: Map String FilePath -> CType -> Set String
has _ CString = S.singleton "<string>"
has m (Vector t) = S.insert "<vector>" (has m t)
has m (List t) = S.insert "<list>" (has m t)
has m (Map k v) = S.insert "<map>" (S.union (has m k) (has m v))
has m (User t) = S.singleton ('\"' : m M.! t ++ "\"")
has _ (Prim "time_t") = S.singleton "<ctime>"
has _ (Prim "size_t") = S.singleton "<cstdlib>"
has _ (Prim _) = S.empty

-- | Determines what files need to be included for a set of packets
includes :: Map String FilePath -> [Packet] -> Set String
includes m = foldl (\inc (Packet _ fs) -> S.union inc $
                      (foldl (\inc2 (Field t _) ->
                               S.union inc2 (has m t)) S.empty fs)) S.empty

-- | Takes the name of a class and converts it to CONSTANT_CASE
constantCase :: String -> String
constantCase "" = ""
constantCase (c:cs) = toUpper c : constantCase' cs
  where
    constantCase' "" = ""
    constantCase' (c:cs)
      | isUpper c = '_' : c : constantCase' cs
      | otherwise = toUpper c : constantCase' cs

-- | Gets the type string for a const-correct type
ccType :: CType -> String
ccType (Prim t) = t ++ " "
ccType t = "const " ++ show t ++ " &"

{---------- Class Definitions (.h) ----------}

-- | Writes the header inclusions
writeIncludes :: Map String FilePath -> [Packet] -> CppWriter
writeIncludes m ps =
  forM_ (S.toList (includes m ps)) (\f -> tellLn ("#include " ++ f))

-- | Writes a field's getter, optionally making it const
getter :: Field -> Bool -> CppWriter
getter (Field t n) const = do
  tell "  "
  tell (if const then ccType t else show t ++ " &")
  tell (init n)
  tell "() "
  when const (tell "const ")
  tellLn $ "{ return " ++ n ++ "; }"
                     
-- | Write's a field's setter
setter :: Field -> CppWriter
setter (Field t n) = do
  tell "  void set"
  tell $ init (capitalize n)
  tell $ '(' : ccType t
  tell "value) { "
  tell n
  tellLn " = value; }"

-- | Writes the accessor methods. Primitives do not need non-const getters
writeAccessors :: [Field] -> CppWriter
writeAccessors fds = do
  forM_ fds (\fd@(Field t _)  -> do
                when (not (isPrim t)) (getter fd False)
                getter fd True
                setter fd
                lnBreak
            )
    
-- | Makes the initialization list constructor
makeCtor :: String -> [Field] -> CppWriter
makeCtor n fds = do
  tell n
  tell "("
  mapM_ tell args
  tell ") : Packet("
  tell $ constantCase n
  tell "), "
  mapM_ tell initList
  tellLn " { }"
  where
    args = intersperse ", " (map argify fds)
    argify (Field t n) = ccType t ++ n
    initList = intersperse ", " (map initF fds)
    initF (Field _ f) = f ++ '(' : f ++ ")"

-- | Makes the default and initialization list constructors
writeCtors :: Packet -> CppWriter
writeCtors (Packet n fds) = do
  tellLn ("  " ++ n ++ "() : Packet(" ++ constantCase n ++ ") { }")
  when (not (null fds)) $ tell "  " >> makeCtor n fds
  lnBreak

-- | Writes the class that appears in the .h file
writeClass :: Packet -> CppWriter
writeClass p@(Packet n fds) = do
  tellLn ("class " ++ n ++ " : public Packet {")
  tellLn "private:"
  forM_ fds (\fd -> do
                tell "  "
                tell (show fd)
                tellLn ";")
  lnBreak
  tellLn "public:"
  writeCtors p
  writeAccessors fds
  tellLn "  unsigned int SerializedSize() const;"
  tellLn "  void Serialize(ByteBuffer &buffer) const;"
  tellLn "  void Deserialize(ByteBuffer &buffer);"
  tellLn "};\n"
  
-- | Writes the header file for a group of packets
writePacketHeader :: String -> [Packet] -> Map String FilePath -> CppWriter
writePacketHeader hdr ps incs = do
  tellLn $ autoComment (hdr ++ ".h")
  tellLn ("#ifndef " ++ guard)
  tellLn ("#define " ++ guard)
  lnBreak
  writeIncludes incs ps
  tellLn "#include \"bytebuffer.h\""
  tellLn "#include \"packet.h\"\n"
  mapM_ writeClass ps
  tell ("#endif // " ++ guard)
  where
    guard = "__" ++ constantCase hdr ++ "_HEADER__"

-- | The constant Packet class
packetClass :: [String]
packetClass = [
  "class Packet {",
  "protected:",
  "  PacketType type;",
  "  unsigned long seqNum;\n",
  "public:",
  "  Packet(PacketType t) : type(t) { }",
  "  virtual ~Packet() { }\n",
  "public:",
  "  PacketType GetPacketType() const { return type; }",
  "  std::string TypeString() const;",
  "  unsigned long SeqNum() const { return seqNum; }",
  "  void SetSeqNum(unsigned long s) { seqNum = s; }\n",
  "  virtual unsigned int SerializedSize() const {",
  "    return sizeof(PacketType) + sizeof(unsigned long);",
  "  }",
  "  virtual void Serialize(ByteBuffer &b) const {", 
  "    b.SerializeInt(static_cast<int>(type));",
  "    b.SerializeLong(seqNum);",
  "  }",
  "  virtual void Deserialize(ByteBuffer &b) { seqNum = b.DeserializeLong(); }\n",
  "  // Returned packet must be deleted",
  "  static Packet *DeserializePacket(ByteBuffer &b);",
  "};\n"
  ]

-- | Write a deserialize case for a packet
writePacketCase :: Bool -> Packet -> CppWriter
writePacketCase b (Packet n _) = do
  if b then tell "  if (type == " else tell "  else if (type == "
  tell (constantCase n)
  tellLn ") {"
  tellLn ("    " ++ n ++ " *packet = new " ++ n ++ "();")
  tellLn "    packet->type = type;"
  tellLn "    packet->Deserialize(b);"
  tellLn "    return packet;"
  tellLn "  }"
              
-- | Writes the packet.cpp file
writePacketImpl :: [String] -> [Packet] -> CppWriter
writePacketImpl fnames ps = do
  tellLn (autoComment "packet.cpp")
  tellLn "#include <string>"
  tellLn "#include \"packet.h\""
  tellLn "#include \"bytebuffer.h\""
  forM_ fnames (\fn -> tellLn ("#include \"" ++ fn ++ ".h\""))
  tellLn "\nstd::string Packet::TypeString() const {"
  tellLn "  switch(type) {"
  forM_ ps (\(Packet n _) -> do
               tellLn ("  case " ++ constantCase n ++ ":")
               tellLn ("    return \"" ++ constantCase n ++ "\";"))
  tellLn "  default:"
  tellLn "    return \"<invalid>\";"
  tellLn "  }"
  tellLn "}\n"
  tellLn "Packet *Packet::DeserializePacket(ByteBuffer &b) {"
  tellLn "  PacketType type = static_cast<PacketType>(b.DeserializeInt());"
  case ps of
    [] -> return ()
    (p:ps) -> do
      writePacketCase True p
      forM_ ps (writePacketCase False)
  tellLn "  return NULL;"
  tellLn "}"
              
-- | Writes the main header file, including the Packet class and enum of
--   packet types
writeMainHeader :: [Packet] -> CppWriter
writeMainHeader ps = do
  tellLn (autoComment "packet.h")
  tellLn "#ifndef __PACKET_HEADER__"
  tellLn "#define __PACKET_HEADER__\n"
  tellLn "#include <string>"
  tellLn "#include \"bytebuffer.h\"\n"
  tellLn "enum PacketType {"
  forM_ ps (\p -> do
               tell "  "
               tell $ constantCase (packetName p)
               tellLn ",")
  tellLn "};\n"
  mapM_ tellLn packetClass
  tell "#endif // __PACKET_HEADER__"
  
{---------- Serialization Methods (.cpp) ----------}
      
-- | The code to find the size of a serialized vector
serSizeList :: String -> CType -> String -> String -> String
serSizeList _ (Prim t) n ws =
  ws ++ "__size += sizeof(unsigned int);\n" ++
  ws ++ "__size += " ++ n ++ ".size() * sizeof(" ++ t ++ ");"
serSizeList c t n ws =
  ws ++ "__size += sizeof(unsigned int);\n" ++
  ws ++ "for (std::" ++ c ++ "<" ++ show t ++ wsTemp t ++
  ">::const_iterator " ++ it ++ " = " ++ n ++ ".begin(); " ++ it ++ " != " ++
  n ++ ".end(); " ++ "++" ++ it ++ ") {\n" ++
  ws2 ++ ccType t ++ tmp ++ " = *" ++ it ++ ";\n" ++
  serializedSize (Field t tmp) ws2 ++ "\n" ++ ws ++ "}"
  where
    ws2 = ' ' : ' ' : ws
    it = n ++ "it"
    tmp = "tmp_" ++ n
    
-- | The code to find the size of a serialized map
serSizeMap :: CType -> CType -> String -> String -> String
serSizeMap (Prim k) (Prim v) n ws =
  ws ++ "__size += sizeof(unsigned int);\n" ++
  ws ++ "__size += " ++ n ++ ".size() * sizeof(" ++ k ++ ");\n" ++
  ws ++ "__size += " ++ n ++ ".size() * sizeof(" ++ v ++ ");"
serSizeMap k v n ws =
  ws ++ "__size += sizeof(unsigned int);\n" ++
  sizeT k ++ sizeT v ++
  ws ++ "for (std::map<" ++ show k ++ ", " ++ show v ++ wsTemp v ++
  ">::const_iterator " ++ it ++ " = " ++ n ++ ".begin(); " ++
  it ++ " != " ++ n ++ ".end(); ++" ++ it ++ ") {\n" ++
  (if isPrim k then "" else
  ws2 ++ ccType k ++ tmpk ++ " = " ++ it ++ "->first;\n" ++
  serializedSize (Field k tmpk) ws2 ++ "\n") ++
  (if isPrim v then "" else
  ws2 ++ ccType v ++ tmpv ++ " = " ++ it ++ "->second;\n" ++
  serializedSize (Field v tmpv) ws2 ++ "\n") ++ ws ++"}"
  where
    ws2 = ' ' : ' ' : ws
    it = n ++ "it"
    tmpk = "tmpk_" ++ n
    tmpv = "tmpv_" ++ n
    sizeT (Prim t) = ws ++ "__size += " ++ n ++ ".size() * sizeof(" ++
                     t ++ ");\n"
    sizeT _ = ""

-- | Gets the name of the de/serialization method
serMethod :: Bool -> String -> String
serMethod d s = "b." ++ m ++ concat (map capitalize (words t))
  where
    t = if isPrefixOf "unsigned " s then drop 9 s else s
    m = if d then "Deserialize" else "Serialize"

-- | The code to serialize a vector
serList :: String -> CType -> String -> String -> String
serList c t n ws =
  ws ++ "b.SerializeInt(" ++ n ++ ".size());\n" ++
  ws ++ "for (std::" ++ c ++ "<" ++ show t ++ wsTemp t ++
  ">::const_iterator " ++ it ++ " = " ++ n ++ ".begin(); " ++ it ++ " != " ++
  n ++ ".end(); ++" ++ it ++ ") {\n" ++ ws2 ++ ccType t ++ tmp ++ " = *" ++
  it ++ ";\n" ++ serialize (Field t tmp) ws2 ++ "\n" ++ ws ++ "}"
  where
    ws2 = ' ' : ' ' : ws
    it = n ++ "it"
    tmp = "tmp_" ++ n
  
-- | The code to serialize a map
serMap :: CType -> CType -> String -> String -> String
serMap k v n ws =
  ws ++ "b.SerializeInt(" ++ n ++ ".size());\n" ++
  ws ++ "for (std::map<" ++ show k ++ ", " ++ show v ++ wsTemp v ++
  ">::const_iterator " ++ it ++ " = " ++ n ++ ".begin(); " ++
  it ++ " != " ++ n ++ ".end(); ++" ++ it ++ ") {\n" ++
  ws2 ++ ccType k ++ tmpk ++ " = " ++ it ++ "->first;\n" ++
  ws2 ++ ccType v ++ tmpv ++ " = " ++ it ++ "->second;\n" ++
  serialize (Field k tmpk) ws2 ++ "\n" ++
  serialize (Field v tmpv) ws2 ++ "\n" ++ ws ++"}"
  where
    ws2 = ' ' : ' ' : ws
    it = n ++ "it"
    tmpk = "tmpk_" ++ n
    tmpv = "tmpv_" ++ n
        
-- | The code to deserialize a vector
deserList :: CType -> String -> String -> String
deserList t n ws =
  ws ++ "unsigned int " ++ size ++ " = b.DeserializeInt();\n" ++
  ws ++ "for (unsigned int " ++ i ++ " = 0; " ++ i ++ " < " ++
  size ++ "; ++" ++ i ++ ") {\n" ++
  ws2 ++ show t ++ ' ' : tmp ++ ";\n" ++
  deserialize (Field t tmp) ws2 ++ "\n" ++
  ws2 ++ n ++ ".push_back(" ++ tmp ++ ");\n" ++ ws ++ "}"
  where
    ws2 = ' ' : ' ' : ws
    size = "size_" ++ n
    i = n ++ "i"
    tmp = "tmp_" ++ n
    
-- | The code to deserialize a map
deserMap :: CType -> CType -> String -> String -> String
deserMap k v n ws =
  ws ++ "unsigned int " ++ size ++ " = b.DeserializeInt();\n" ++
  ws ++ "for (unsigned int " ++ i ++ " = 0; " ++ i ++ " < " ++
  size ++ "; ++" ++ i ++ ") {\n" ++
  ws2 ++ show k ++ ' ' : tmpk ++ ";\n" ++
  ws2 ++ show v ++ ' ' : tmpv ++ ";\n" ++
  deserialize (Field k tmpk) ws2 ++ "\n" ++
  deserialize (Field v tmpv) ws2 ++ "\n" ++
  ws2 ++ n ++ '[' : tmpk ++ "] = " ++ tmpv ++ ";\n" ++ ws ++ "}"
  where
    ws2 = ' ' : ' ' : ws
    size = "size_" ++ n
    i = n ++ "i"
    tmpk = "tmpk_" ++ n
    tmpv = "tmpv_" ++ n

-- | The code to get the size of a serialized field
serializedSize :: Field -> String -> String
serializedSize (Field CString n) ws = ws ++ "__size += " ++ n ++ ".size() + 1;"
serializedSize (Field (User _) n) ws = ws ++ "__size += " ++ n ++
                                       ".SerializedSize();"
serializedSize (Field (Prim t) _) ws = ws ++ "__size += sizeof(" ++ t ++ ");"
serializedSize (Field (Vector t) n) ws = serSizeList "vector" t n ws
serializedSize (Field (List t) n) ws = serSizeList "list" t n ws
serializedSize (Field (Map k v) n) ws = serSizeMap k v n ws

-- | The code to serialize a field
serialize :: Field -> String -> String
serialize (Field CString n) ws = ws ++ serMethod False "string" ++
                                  '(' : n ++ ");"
serialize (Field (User _) n) ws = ws ++ n ++ ".Serialize(b);"
serialize (Field (Prim t) n) ws = ws ++ serMethod False t ++
                                   '(' : n ++ ");"
serialize (Field (Vector t) n) ws = serList "vector" t n ws
serialize (Field (List t) n) ws = serList "list" t n ws
serialize (Field (Map k v) n) ws = serMap k v n ws

-- | The code to deserialize a field
deserialize :: Field -> String -> String
deserialize (Field CString n) ws = ws ++ n ++ " = " ++
                                    serMethod True "string" ++ "();"
deserialize (Field (User _) n) ws = ws ++ n ++ ".Deserialize(b);"
deserialize (Field (Prim t) n) ws = ws ++ n ++ " = " ++
                                     serMethod True t ++ "();"
deserialize (Field (Vector t) n) ws = deserList t n ws
deserialize (Field (List t) n) ws = deserList t n ws
deserialize (Field (Map k v) n) ws = deserMap k v n ws

-- | The code to get the size of a serialized packet
writeSerializedSize :: Packet -> CppWriter
writeSerializedSize (Packet n fds) = do
  tellLn ("unsigned int " ++ n ++ "::SerializedSize() const {")
  tellLn "  unsigned int __size = Packet::SerializedSize();"
  forM_ fds (\fd -> tellLn (serializedSize fd "  "))
  tellLn "  return __size;"
  tellLn "}\n"

-- | The code to serialize a packet
writeSerialize :: Packet -> CppWriter
writeSerialize (Packet n fds) = do
  tellLn ("void " ++ n ++ "::Serialize(ByteBuffer &b) const {")
  tellLn "  Packet::Serialize(b);"
  forM_ fds (\fd -> tellLn (serialize fd "  "))
  tellLn "}\n"
  
-- | The code to deserialize a packet
writeDeserialize :: Packet -> CppWriter
writeDeserialize (Packet n fds) = do
  tellLn ("void " ++ n ++ "::Deserialize(ByteBuffer &b) {")
  tellLn "  Packet::Deserialize(b);"
  forM_ fds (\fd -> tellLn (deserialize fd "  "))
  tellLn "}\n"

-- | The code to write the .cpp file for a group of packets
writeCppFile :: String -> [Packet] -> Map String FilePath -> CppWriter
writeCppFile name ps incs = do
  tellLn $ autoComment (name ++ ".cpp")
  writeIncludes incs ps
  tellLn "#include \"bytebuffer.h\""
  tellLn "#include \"packet.h\""
  tellLn ("#include \"" ++ name ++ ".h\"\n")
  forM_ ps (\p -> do
               writeSerializedSize p
               writeSerialize p
               writeDeserialize p
           )
    
{---------- Main IO ----------}
  
-- | Prints usage instructions
printUsage :: IO ()
printUsage = do
  putStrLn "Nick's Packet Compiler"
  putStrLn "Auto-generates C++ code for packet classes given fields. There are" 
  putStrLn "two possible invocations:\n"
  putStrLn "npc [--inc=FILE] packet1 [packet2] ..."
  putStrLn "npc [--inc=FILE] --all\n"
  putStrLn "The first invocation will create .h and .cpp files for each packet" 
  putStrLn "file specified."
  putStrLn "The second invocation is equivalent to invoking 'npc' with"
  putStrLn "every .packet file in the current directory."
  putStrLn "The inc option is used to specify the file of inclusions for"
  putStrLn "user-defined classes."
  
data Flag =
    All
  | Includes (Maybe String)
  deriving (Eq, Show)
           
getInc' :: Flag -> Maybe String
getInc' All = Nothing
getInc' (Includes s) = s

getInc :: [Flag] -> String
getInc flgs = case mapMaybe getInc' flgs of
  []    -> ""
  (f:_) -> f
    
options :: [OptDescr Flag]
options = [
  Option ['a'] ["all"] (NoArg All) "compile all packets in directory",
  Option ['i'] ["inc"] (OptArg Includes "FILE") "mappings of classes to header files"
  ]
          
-- | Gets the files whose extension is .packet
getFiles :: IO [FilePath]
getFiles = do
  cd <- getCurrentDirectory
  files <- getDirectoryContents cd
  return (filter (\f -> takeExtension f == ".packet") files)

-- | Writes all the packet files
npc' :: [FilePath] -> [[Packet]] -> Map String FilePath -> IO ()
npc' packetFiles packets incs = do
  forM_ (zip packetFiles packets)
        (\(name,ps) -> do
            base <- return (dropExtension name)
            writeFile (base ++ ".h") $
              execWriter (writePacketHeader base ps incs)
            putStrLn ("Created " ++ base ++ ".h")
            writeFile (base ++ ".cpp") $ execWriter (writeCppFile base ps incs)
            putStrLn ("Created " ++ base ++ ".cpp")
        )

-- | Generates all the files
npc :: [FilePath] -> [Flag] -> IO ()
npc packetFiles flgs = do
  results <- sequence (map parsePackets packetFiles)
  case sequence results of
    Left err -> print err
    -- packets :: [[Packet]]
    Right packets -> do
      writeFile "packet.h" $ execWriter (writeMainHeader (concat packets))
      putStrLn "Created packet.h"
      writeFile "packet.cpp" $
        execWriter (writePacketImpl (map dropExtension packetFiles)
                    (concat packets))
      putStrLn "Created packet.cpp"
      -- Parse the inclusions file
      incFile <- return (getInc flgs)
      incs' <- if null incFile then (return (Right M.empty))
               else parseIncludes incFile
      case incs' of
        Left err -> print err
        Right incs -> npc' packetFiles packets incs
      

-- | Reads the input and generates the packet files
main :: IO ()
main = do
  argv <- getArgs
  when (null argv) (printUsage >> exitSuccess)
  case getOpt Permute options argv of
    (flgs,fs,[]) -> do
      packetFiles <- if elem All flgs then getFiles else return fs
      when (null packetFiles) (printUsage >> exitFailure)
      npc packetFiles flgs
    (_,_,errs) -> ioError (userError (concat errs ++ usageInfo info options))
  where info = "Usage: npc [OPTION...] files..."
      npc-1.5/PacketParser.hs0000664000175000017500000001130512135057127013516 0ustar  nicknick{-# OPTIONS -Wall -fno-warn-name-shadowing -fno-warn-unused-do-bind #-}

module PacketParser (
  CType(..),
  Field(..),
  Packet(..),
  packetName,
  isPrim,
  wsTemp,
  parsePackets,
  parseIncludes
  ) where

import Control.Monad
import Data.Map (Map)
import qualified Data.Map as M
import Data.Maybe (catMaybes)
import Text.ParserCombinators.Parsec

{-

packet <name> {
  <C_type> <field_name>;
  ...
}

-}

data CType =
    CString
  | Prim String
  | User String
  | Vector CType
  | List CType
  | Map CType CType

data Field = Field CType String
data Packet = Packet String [Field] deriving Show

instance Show CType where
  show CString = "std::string"
  show (Prim s) = s
  show (User s) = s
  show (Vector t) = "std::vector<" ++ show t ++ wsTemp t ++ ">"
  show (List t) = "std::list<" ++ show t ++ wsTemp t ++ ">"
  show (Map t1 t2) = "std::map<" ++ show t1 ++ ", " ++ show t2 ++
                     wsTemp t2 ++ ">"

instance Show Field where
  show (Field t n) = show t ++ ' ' : n
  
packetName :: Packet -> String
packetName (Packet n _) = n

isPrim :: CType -> Bool
isPrim (Prim _) = True
isPrim _ = False

wsTemp :: CType -> String
wsTemp (Vector _) = " "
wsTemp (List _) = " "
wsTemp (Map _ _) = " "
wsTemp _ = ""

skip :: Parser a -> Parser ()
skip = liftM (const ())

spaces1 :: Parser ()
spaces1 = skip (many1 space)

listP :: String -> Parser CType
listP c = do
  string c
  spaces
  char '<'
  spaces
  t <- typeP
  spaces
  char '>'
  return (if c == "list" then List t else Vector t)  
  
mapP :: Parser CType
mapP = do
  string "map"
  spaces
  char '<'
  spaces
  k <- typeP
  spaces
  char ','
  spaces
  v <- typeP
  spaces
  char '>'
  return (Map k v)
  
numTypeP :: Bool -> Parser String
numTypeP unsigned =
  string "char" <|> string "int" <|> short <|>
  case unsigned of
    True -> long True
    False -> string "bool" <|> string "float" <|>
             string "double" <|> long False
  where
    intOpt s = (try (spaces1 >> string "int") <|> return "") >> return s
    short = do
      string "short"
      intOpt "short"
    long b = do
      string "long"
      (case b of
        True -> fail "Doubles may not be unsigned"
        False -> try (spaces1 >> string "double" >> return "long double")
        ) <|>
        try (spaces1 >> string "long" >> intOpt "long long") <|>
        intOpt "long"
  
unsignedP :: Parser CType
unsignedP = do
  string "unsigned"
  spaces1
  t <- numTypeP True <?> "Illegal use of unsigned"
  return (Prim ("unsigned " ++ t))
  
typedefP :: Parser CType
typedefP = liftM Prim (string "time_t" <|> string "size_t")
  
primitiveP :: Parser CType
primitiveP = try typedefP <|> unsignedP <|> liftM Prim (numTypeP False)

nameP :: Parser String
nameP = do
  first <- letter <|> char '_'
  rest <- many (alphaNum <|> char '_')
  return (first : rest)

typeP :: Parser CType
typeP = try (listP "vector") <|> try (listP "list") <|> try mapP <|>
        try primitiveP <|> try stringP <|> userP
  where
    stringP = string "string" >> return CString
    userP = liftM User nameP
  
commentP :: Parser (Maybe a)
commentP = do
  string "//"
  many (noneOf "\n")
  spaces
  return Nothing
  
fieldP :: Parser (Maybe Field)
fieldP = commentP <|> do
  ctype <- typeP
  spaces1
  fname <- nameP
  spaces
  char ';'
  spaces
  return (Just (Field ctype (fname ++ "_")))

commentPacketP :: Parser (Maybe Packet)
commentPacketP = string "/*" >> findClose >> return Nothing
  where
    findClose = do
      skipMany (noneOf "*")
      char '*'
      skip (char '/') <|> findClose
      spaces

packetP :: Parser (Maybe Packet)
packetP = commentPacketP <|> do
  string "packet"
  spaces1
  name <- nameP
  spaces
  char '{'
  spaces
  fields <- liftM catMaybes (many fieldP)
  char '}'
  spaces
  return (Just (Packet name fields))
  
packetFileP :: Parser [Packet]
packetFileP = do
  spaces
  packets <- liftM catMaybes (many packetP)
  eof
  return packets
  
-- | Parses a .packet file and returns a list of packets, or an error
parsePackets :: FilePath -> IO (Either ParseError [Packet])
parsePackets = parseFromFile packetFileP

_packet :: String -> IO ()
_packet file = do
  res <- parseFromFile packetFileP file
  case res of
    Left error -> print error
    Right packets -> print packets
    
headerP :: Parser FilePath
headerP = many1 (alphaNum <|> char '_' <|> char '.' <|> char '-')

includeP :: Parser (Maybe (String, FilePath))
includeP = do
  ctype <- nameP
  spaces
  char ':'
  spaces
  hname <- headerP
  spaces
  char ';'
  spaces
  return $ Just (ctype, hname)
  
includesP :: Parser (Map String FilePath)
includesP = liftM (M.fromList . catMaybes) $ many (commentP <|> includeP)
    
-- | Parses an inclusions file
parseIncludes :: FilePath -> IO (Either ParseError (Map String FilePath))
parseIncludes = parseFromFile includesP