🎨 Committing clang-format changes

include/chaiscript/language/chaiscript_engine.hpp

@@ -142,8 +142,9 @@ namespace chaiscript {
                    "set_print_handler");
 
       m_engine.add(fun([this](const std::function<std::string(const std::string &)> &t_reader) {
-        m_file_reader = t_reader;
-      }), "set_file_reader");
+                     m_file_reader = t_reader;
+                   }),
+                   "set_file_reader");
 
       m_engine.add(fun([this]() { m_engine.dump_system(); }), "dump_system");
       m_engine.add(fun([this](const Boxed_Value &t_bv) { m_engine.dump_object(t_bv); }), "dump_object");

src/sha3.h

@@ -6,20 +6,19 @@
 
 #pragma once
 
-//#include "hash.h"
+// #include "hash.h"
 #include <string>
 
 // define fixed size integer types
 #ifdef _MSC_VER
 // Windows
-typedef unsigned __int8  uint8_t;
+typedef unsigned __int8 uint8_t;
 typedef unsigned __int64 uint64_t;
 #else
 // GCC
 #include <stdint.h>
 #endif
 
-
 /// compute SHA3 hash
 /** Usage:
     SHA3 sha3;
@@ -37,18 +36,21 @@ class SHA3 //: public Hash
 {
 public:
   /// algorithm variants
-  enum Bits { Bits224 = 224, Bits256 = 256, Bits384 = 384, Bits512 = 512 };
+  enum Bits { Bits224 = 224,
+              Bits256 = 256,
+              Bits384 = 384,
+              Bits512 = 512 };
 
   /// same as reset()
   explicit SHA3(Bits bits = Bits256);
 
   /// compute hash of a memory block
-  std::string operator()(const void* data, size_t numBytes);
+  std::string operator()(const void *data, size_t numBytes);
   /// compute hash of a string, excluding final zero
-  std::string operator()(const std::string& text);
+  std::string operator()(const std::string &text);
 
   /// add arbitrary number of bytes
-  void add(const void* data, size_t numBytes);
+  void add(const void *data, size_t numBytes);
 
   /// return latest hash as hex characters
   std::string getHash();
@@ -58,24 +60,24 @@ public:
 
 private:
   /// process a full block
-  void processBlock(const void* data);
+  void processBlock(const void *data);
   /// process everything left in the internal buffer
   void processBuffer();
 
   /// 1600 bits, stored as 25x64 bit, BlockSize is no more than 1152 bits (Keccak224)
-  enum { StateSize    = 1600 / (8 * 8),
-         MaxBlockSize =  200 - 2 * (224 / 8) };
+  enum { StateSize = 1600 / (8 * 8),
+         MaxBlockSize = 200 - 2 * (224 / 8) };
 
   /// hash
   uint64_t m_hash[StateSize];
   /// size of processed data in bytes
   uint64_t m_numBytes;
   /// block size (less or equal to MaxBlockSize)
-  size_t   m_blockSize;
+  size_t m_blockSize;
   /// valid bytes in m_buffer
-  size_t   m_bufferSize;
+  size_t m_bufferSize;
   /// bytes not processed yet
-  uint8_t  m_buffer[MaxBlockSize];
+  uint8_t m_buffer[MaxBlockSize];
   /// variant
-  Bits     m_bits;
+  Bits m_bits;
 };