Update generator to new clang

layus · Nov 6, 2020 · d4e6d89 · d4e6d89
1 parent 4806504
commit d4e6d89
Show file tree

Hide file tree

Showing 306 changed files with 2,556 additions and 2,585 deletions.
diff --git a/vm/boostenv/main/cached/Abstraction-implem-decl-after.hh b/vm/boostenv/main/cached/Abstraction-implem-decl-after.hh
@@ -51,44 +51,44 @@ public:
   size_t getArraySize();
 
   inline
-  StaticArray<class mozart::StableNode> getElementsArray();
+  StaticArray<mozart::StableNode> getElementsArray();
 
   inline
-  class mozart::StableNode& getElements(size_t i);
+  mozart::StableNode& getElements(size_t i);
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
   size_t getArraySizeImpl();
 
   inline
-  atom_t getPrintName(VM vm);
+  mozart::atom_t getPrintName(mozart::VM vm);
 
   inline
-  bool isCallable(VM vm);
+  bool isCallable(mozart::VM vm);
 
   inline
-  bool isProcedure(VM vm);
+  bool isProcedure(mozart::VM vm);
 
   inline
-  size_t procedureArity(VM vm);
+  size_t procedureArity(mozart::VM vm);
 
   inline
-  void getCallInfo(VM vm, size_t & arity, ProgramCounter & start, size_t & Xcount, StaticArray<class mozart::StableNode> & Gs, StaticArray<class mozart::StableNode> & Ks);
+  void getCallInfo(mozart::VM vm, size_t & arity, mozart::ProgramCounter & start, size_t & Xcount, StaticArray<mozart::StableNode> & Gs, StaticArray<mozart::StableNode> & Ks);
 
   inline
-  void getDebugInfo(VM vm, atom_t & printName, class mozart::UnstableNode & debugData);
+  void getDebugInfo(mozart::VM vm, mozart::atom_t & printName, mozart::UnstableNode & debugData);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 
   inline
-  class mozart::GlobalNode * globalize(VM vm);
+  mozart::GlobalNode * globalize(mozart::VM vm);
 
   inline
-  void setUUID(VM vm, const struct mozart::UUID & uuid);
+  void setUUID(mozart::VM vm, const mozart::UUID & uuid);
 };
diff --git a/vm/boostenv/main/cached/Abstraction-implem-decl.hh b/vm/boostenv/main/cached/Abstraction-implem-decl.hh
@@ -3,5 +3,5 @@ class Abstraction;
 template <>
 class Storage<Abstraction> {
 public:
-  typedef ImplWithArray<Abstraction, class mozart::StableNode> Type;
+  typedef ImplWithArray<Abstraction, mozart::StableNode> Type;
 };
diff --git a/vm/boostenv/main/cached/Abstraction-implem.hh b/vm/boostenv/main/cached/Abstraction-implem.hh
@@ -47,16 +47,16 @@ size_t TypedRichNode<Abstraction>::getArraySize() {
   return _self.access<Abstraction>().getArraySize();
 }
 
-StaticArray<class mozart::StableNode> TypedRichNode<Abstraction>::getElementsArray() {
+StaticArray<mozart::StableNode> TypedRichNode<Abstraction>::getElementsArray() {
   return _self.access<Abstraction>().getElementsArray();
 }
 
-class mozart::StableNode& TypedRichNode<Abstraction>::getElements(size_t i) {
+mozart::StableNode& TypedRichNode<Abstraction>::getElements(size_t i) {
   return _self.access<Abstraction>().getElements(i);
 }
 
 inline
-class mozart::Space *  TypedRichNode<Abstraction>::home() {
+mozart::Space *  TypedRichNode<Abstraction>::home() {
   return _self.access<Abstraction>().home();
 }
 
@@ -66,51 +66,51 @@ size_t  TypedRichNode<Abstraction>::getArraySizeImpl() {
 }
 
 inline
-atom_t  TypedRichNode<Abstraction>::getPrintName(VM vm) {
+mozart::atom_t  TypedRichNode<Abstraction>::getPrintName(mozart::VM vm) {
   return _self.access<Abstraction>().getPrintName(vm);
 }
 
 inline
-bool  TypedRichNode<Abstraction>::isCallable(VM vm) {
+bool  TypedRichNode<Abstraction>::isCallable(mozart::VM vm) {
   return _self.access<Abstraction>().isCallable(vm);
 }
 
 inline
-bool  TypedRichNode<Abstraction>::isProcedure(VM vm) {
+bool  TypedRichNode<Abstraction>::isProcedure(mozart::VM vm) {
   return _self.access<Abstraction>().isProcedure(vm);
 }
 
 inline
-size_t  TypedRichNode<Abstraction>::procedureArity(VM vm) {
+size_t  TypedRichNode<Abstraction>::procedureArity(mozart::VM vm) {
   return _self.access<Abstraction>().procedureArity(vm);
 }
 
 inline
-void  TypedRichNode<Abstraction>::getCallInfo(VM vm, size_t & arity, ProgramCounter & start, size_t & Xcount, StaticArray<class mozart::StableNode> & Gs, StaticArray<class mozart::StableNode> & Ks) {
+void  TypedRichNode<Abstraction>::getCallInfo(mozart::VM vm, size_t & arity, mozart::ProgramCounter & start, size_t & Xcount, StaticArray<mozart::StableNode> & Gs, StaticArray<mozart::StableNode> & Ks) {
   _self.access<Abstraction>().getCallInfo(vm, arity, start, Xcount, Gs, Ks);
 }
 
 inline
-void  TypedRichNode<Abstraction>::getDebugInfo(VM vm, atom_t & printName, class mozart::UnstableNode & debugData) {
+void  TypedRichNode<Abstraction>::getDebugInfo(mozart::VM vm, mozart::atom_t & printName, mozart::UnstableNode & debugData) {
   _self.access<Abstraction>().getDebugInfo(vm, printName, debugData);
 }
 
 inline
-void  TypedRichNode<Abstraction>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Abstraction>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Abstraction>().printReprToStream(vm, out, depth, width);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Abstraction>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<Abstraction>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<Abstraction>().serialize(vm, se);
 }
 
 inline
-class mozart::GlobalNode *  TypedRichNode<Abstraction>::globalize(VM vm) {
+mozart::GlobalNode *  TypedRichNode<Abstraction>::globalize(mozart::VM vm) {
   return _self.access<Abstraction>().globalize(_self, vm);
 }
 
 inline
-void  TypedRichNode<Abstraction>::setUUID(VM vm, const struct mozart::UUID & uuid) {
+void  TypedRichNode<Abstraction>::setUUID(mozart::VM vm, const mozart::UUID & uuid) {
   _self.access<Abstraction>().setUUID(_self, vm, uuid);
 }
diff --git a/vm/boostenv/main/cached/Arity-implem-decl-after.hh b/vm/boostenv/main/cached/Arity-implem-decl-after.hh
@@ -48,32 +48,32 @@ public:
   size_t getArraySize();
 
   inline
-  StaticArray<class mozart::StableNode> getElementsArray();
+  StaticArray<mozart::StableNode> getElementsArray();
 
   inline
-  class mozart::StableNode& getElements(size_t i);
+  mozart::StableNode& getElements(size_t i);
 
   inline
   size_t getArraySizeImpl();
 
   inline
-  class mozart::StableNode * getLabel();
+  mozart::StableNode * getLabel();
 
   inline
   size_t getWidth();
 
   inline
-  class mozart::StableNode * getElement(size_t index);
+  mozart::StableNode * getElement(size_t index);
 
   inline
-  bool equals(VM vm, class mozart::RichNode right, class mozart::WalkStack & stack);
+  bool equals(mozart::VM vm, mozart::RichNode right, mozart::WalkStack & stack);
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, size_t & offset);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, size_t & offset);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 
   inline
-  class mozart::UnstableNode serialize(VM vm, SE se);
+  mozart::UnstableNode serialize(mozart::VM vm, mozart::SE se);
 };
diff --git a/vm/boostenv/main/cached/Arity-implem-decl.hh b/vm/boostenv/main/cached/Arity-implem-decl.hh
@@ -3,5 +3,5 @@ class Arity;
 template <>
 class Storage<Arity> {
 public:
-  typedef ImplWithArray<Arity, class mozart::StableNode> Type;
+  typedef ImplWithArray<Arity, mozart::StableNode> Type;
 };
diff --git a/vm/boostenv/main/cached/Arity-implem.hh b/vm/boostenv/main/cached/Arity-implem.hh
@@ -34,11 +34,11 @@ size_t TypedRichNode<Arity>::getArraySize() {
   return _self.access<Arity>().getArraySize();
 }
 
-StaticArray<class mozart::StableNode> TypedRichNode<Arity>::getElementsArray() {
+StaticArray<mozart::StableNode> TypedRichNode<Arity>::getElementsArray() {
   return _self.access<Arity>().getElementsArray();
 }
 
-class mozart::StableNode& TypedRichNode<Arity>::getElements(size_t i) {
+mozart::StableNode& TypedRichNode<Arity>::getElements(size_t i) {
   return _self.access<Arity>().getElements(i);
 }
 
@@ -48,7 +48,7 @@ size_t  TypedRichNode<Arity>::getArraySizeImpl() {
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<Arity>::getLabel() {
+mozart::StableNode *  TypedRichNode<Arity>::getLabel() {
   return _self.access<Arity>().getLabel();
 }
 
@@ -58,26 +58,26 @@ size_t  TypedRichNode<Arity>::getWidth() {
 }
 
 inline
-class mozart::StableNode *  TypedRichNode<Arity>::getElement(size_t index) {
+mozart::StableNode *  TypedRichNode<Arity>::getElement(size_t index) {
   return _self.access<Arity>().getElement(index);
 }
 
 inline
-bool  TypedRichNode<Arity>::equals(VM vm, class mozart::RichNode right, class mozart::WalkStack & stack) {
+bool  TypedRichNode<Arity>::equals(mozart::VM vm, mozart::RichNode right, mozart::WalkStack & stack) {
   return _self.access<Arity>().equals(vm, right, stack);
 }
 
 inline
-bool  TypedRichNode<Arity>::lookupFeature(VM vm, class mozart::RichNode feature, size_t & offset) {
+bool  TypedRichNode<Arity>::lookupFeature(mozart::VM vm, mozart::RichNode feature, size_t & offset) {
   return _self.access<Arity>().lookupFeature(vm, feature, offset);
 }
 
 inline
-void  TypedRichNode<Arity>::printReprToStream(VM vm, std::ostream & out, int depth, int width) {
+void  TypedRichNode<Arity>::printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width) {
   _self.access<Arity>().printReprToStream(vm, out, depth, width);
 }
 
 inline
-class mozart::UnstableNode  TypedRichNode<Arity>::serialize(VM vm, SE se) {
+mozart::UnstableNode  TypedRichNode<Arity>::serialize(mozart::VM vm, mozart::SE se) {
   return _self.access<Arity>().serialize(vm, se);
 }
diff --git a/vm/boostenv/main/cached/Array-implem-decl-after.hh b/vm/boostenv/main/cached/Array-implem-decl-after.hh
@@ -45,19 +45,19 @@ public:
   size_t getArraySize();
 
   inline
-  StaticArray<class mozart::UnstableNode> getElementsArray();
+  StaticArray<mozart::UnstableNode> getElementsArray();
 
   inline
-  class mozart::UnstableNode& getElements(size_t i);
+  mozart::UnstableNode& getElements(size_t i);
 
   inline
-  class mozart::Space * home();
+  mozart::Space * home();
 
   inline
-  bool lookupFeature(VM vm, class mozart::RichNode feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::RichNode feature, nullable<mozart::UnstableNode &> value);
 
   inline
-  bool lookupFeature(VM vm, nativeint feature, nullable<class mozart::UnstableNode &> value);
+  bool lookupFeature(mozart::VM vm, mozart::nativeint feature, nullable<mozart::UnstableNode &> value);
 
   inline
   size_t getArraySizeImpl();
@@ -66,35 +66,35 @@ public:
   size_t getWidth();
 
   inline
-  nativeint getLow();
+  mozart::nativeint getLow();
 
   inline
-  nativeint getHigh();
+  mozart::nativeint getHigh();
 
   inline
-  void dotAssign(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue);
+  void dotAssign(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue);
 
   inline
-  class mozart::UnstableNode dotExchange(VM vm, class mozart::RichNode feature, class mozart::RichNode newValue);
+  mozart::UnstableNode dotExchange(mozart::VM vm, mozart::RichNode feature, mozart::RichNode newValue);
 
   inline
-  bool isArray(VM vm);
+  bool isArray(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arrayLow(VM vm);
+  mozart::UnstableNode arrayLow(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arrayHigh(VM vm);
+  mozart::UnstableNode arrayHigh(mozart::VM vm);
 
   inline
-  class mozart::UnstableNode arrayGet(VM vm, class mozart::RichNode index);
+  mozart::UnstableNode arrayGet(mozart::VM vm, mozart::RichNode index);
 
   inline
-  void arrayPut(VM vm, class mozart::RichNode index, class mozart::RichNode value);
+  void arrayPut(mozart::VM vm, mozart::RichNode index, mozart::RichNode value);
 
   inline
-  class mozart::UnstableNode arrayExchange(VM vm, class mozart::RichNode index, class mozart::RichNode newValue);
+  mozart::UnstableNode arrayExchange(mozart::VM vm, mozart::RichNode index, mozart::RichNode newValue);
 
   inline
-  void printReprToStream(VM vm, std::ostream & out, int depth, int width);
+  void printReprToStream(mozart::VM vm, std::ostream & out, int depth, int width);
 };
diff --git a/vm/boostenv/main/cached/Array-implem-decl.hh b/vm/boostenv/main/cached/Array-implem-decl.hh
@@ -3,5 +3,5 @@ class Array;
 template <>
 class Storage<Array> {
 public:
-  typedef ImplWithArray<Array, class mozart::UnstableNode> Type;
+  typedef ImplWithArray<Array, mozart::UnstableNode> Type;
 };