Where Online Learning is simpler!

The C and C++ Include Header Files

cat -n /usr/include/wabt/expr-visitor.h

     1	/*
     2	 * Copyright 2017 WebAssembly Community Group participants
     3	 *
     4	 * Licensed under the Apache License, Version 2.0 (the "License");
     5	 * you may not use this file except in compliance with the License.
     6	 * You may obtain a copy of the License at
     7	 *
     8	 *     http://www.apache.org/licenses/LICENSE-2.0
     9	 *
    10	 * Unless required by applicable law or agreed to in writing, software
    11	 * distributed under the License is distributed on an "AS IS" BASIS,
    12	 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13	 * See the License for the specific language governing permissions and
    14	 * limitations under the License.
    15	 */
    16	
    17	#ifndef WABT_EXPR_VISITOR_H_
    18	#define WABT_EXPR_VISITOR_H_
    19	
    20	#include "wabt/common.h"
    21	#include "wabt/ir.h"
    22	
    23	namespace wabt {
    24	
    25	class ExprVisitor {
    26	 public:
    27	  class Delegate;
    28	  class DelegateNop;
    29	
    30	  explicit ExprVisitor(Delegate* delegate);
    31	
    32	  Result VisitExpr(Expr*);
    33	  Result VisitExprList(ExprList&);
    34	  Result VisitFunc(Func*);
    35	
    36	 private:
    37	  enum class State {
    38	    Default,
    39	    Block,
    40	    IfTrue,
    41	    IfFalse,
    42	    Loop,
    43	    Try,
    44	    Catch,
    45	  };
    46	
    47	  Result HandleDefaultState(Expr*);
    48	  void PushDefault(Expr*);
    49	  void PopDefault();
    50	  void PushExprlist(State state, Expr*, ExprList&);
    51	  void PopExprlist();
    52	  void PushCatch(Expr*, Index catch_index, ExprList&);
    53	  void PopCatch();
    54	
    55	  Delegate* delegate_;
    56	
    57	  // Use parallel arrays instead of array of structs so we can avoid allocating
    58	  // unneeded objects. ExprList::iterator has no default constructor, so it
    59	  // must only be allocated for states that use it.
    60	  std::vector<State> state_stack_;
    61	  std::vector<Expr*> expr_stack_;
    62	  std::vector<ExprList::iterator> expr_iter_stack_;
    63	  std::vector<Index> catch_index_stack_;
    64	};
    65	
    66	class ExprVisitor::Delegate {
    67	 public:
    68	  virtual ~Delegate() {}
    69	
    70	  virtual Result OnBinaryExpr(BinaryExpr*) = 0;
    71	  virtual Result BeginBlockExpr(BlockExpr*) = 0;
    72	  virtual Result EndBlockExpr(BlockExpr*) = 0;
    73	  virtual Result OnBrExpr(BrExpr*) = 0;
    74	  virtual Result OnBrIfExpr(BrIfExpr*) = 0;
    75	  virtual Result OnBrTableExpr(BrTableExpr*) = 0;
    76	  virtual Result OnCallExpr(CallExpr*) = 0;
    77	  virtual Result OnCallIndirectExpr(CallIndirectExpr*) = 0;
    78	  virtual Result OnCallRefExpr(CallRefExpr*) = 0;
    79	  virtual Result OnCodeMetadataExpr(CodeMetadataExpr*) = 0;
    80	  virtual Result OnCompareExpr(CompareExpr*) = 0;
    81	  virtual Result OnConstExpr(ConstExpr*) = 0;
    82	  virtual Result OnConvertExpr(ConvertExpr*) = 0;
    83	  virtual Result OnDropExpr(DropExpr*) = 0;
    84	  virtual Result OnGlobalGetExpr(GlobalGetExpr*) = 0;
    85	  virtual Result OnGlobalSetExpr(GlobalSetExpr*) = 0;
    86	  virtual Result BeginIfExpr(IfExpr*) = 0;
    87	  virtual Result AfterIfTrueExpr(IfExpr*) = 0;
    88	  virtual Result EndIfExpr(IfExpr*) = 0;
    89	  virtual Result OnLoadExpr(LoadExpr*) = 0;
    90	  virtual Result OnLocalGetExpr(LocalGetExpr*) = 0;
    91	  virtual Result OnLocalSetExpr(LocalSetExpr*) = 0;
    92	  virtual Result OnLocalTeeExpr(LocalTeeExpr*) = 0;
    93	  virtual Result BeginLoopExpr(LoopExpr*) = 0;
    94	  virtual Result EndLoopExpr(LoopExpr*) = 0;
    95	  virtual Result OnMemoryCopyExpr(MemoryCopyExpr*) = 0;
    96	  virtual Result OnDataDropExpr(DataDropExpr*) = 0;
    97	  virtual Result OnMemoryFillExpr(MemoryFillExpr*) = 0;
    98	  virtual Result OnMemoryGrowExpr(MemoryGrowExpr*) = 0;
    99	  virtual Result OnMemoryInitExpr(MemoryInitExpr*) = 0;
   100	  virtual Result OnMemorySizeExpr(MemorySizeExpr*) = 0;
   101	  virtual Result OnTableCopyExpr(TableCopyExpr*) = 0;
   102	  virtual Result OnElemDropExpr(ElemDropExpr*) = 0;
   103	  virtual Result OnTableInitExpr(TableInitExpr*) = 0;
   104	  virtual Result OnTableGetExpr(TableGetExpr*) = 0;
   105	  virtual Result OnTableSetExpr(TableSetExpr*) = 0;
   106	  virtual Result OnTableGrowExpr(TableGrowExpr*) = 0;
   107	  virtual Result OnTableSizeExpr(TableSizeExpr*) = 0;
   108	  virtual Result OnTableFillExpr(TableFillExpr*) = 0;
   109	  virtual Result OnRefFuncExpr(RefFuncExpr*) = 0;
   110	  virtual Result OnRefNullExpr(RefNullExpr*) = 0;
   111	  virtual Result OnRefIsNullExpr(RefIsNullExpr*) = 0;
   112	  virtual Result OnNopExpr(NopExpr*) = 0;
   113	  virtual Result OnReturnExpr(ReturnExpr*) = 0;
   114	  virtual Result OnReturnCallExpr(ReturnCallExpr*) = 0;
   115	  virtual Result OnReturnCallIndirectExpr(ReturnCallIndirectExpr*) = 0;
   116	  virtual Result OnSelectExpr(SelectExpr*) = 0;
   117	  virtual Result OnStoreExpr(StoreExpr*) = 0;
   118	  virtual Result OnUnaryExpr(UnaryExpr*) = 0;
   119	  virtual Result OnUnreachableExpr(UnreachableExpr*) = 0;
   120	  virtual Result BeginTryExpr(TryExpr*) = 0;
   121	  virtual Result OnCatchExpr(TryExpr*, Catch*) = 0;
   122	  virtual Result OnDelegateExpr(TryExpr*) = 0;
   123	  virtual Result EndTryExpr(TryExpr*) = 0;
   124	  virtual Result OnThrowExpr(ThrowExpr*) = 0;
   125	  virtual Result OnRethrowExpr(RethrowExpr*) = 0;
   126	  virtual Result OnAtomicWaitExpr(AtomicWaitExpr*) = 0;
   127	  virtual Result OnAtomicFenceExpr(AtomicFenceExpr*) = 0;
   128	  virtual Result OnAtomicNotifyExpr(AtomicNotifyExpr*) = 0;
   129	  virtual Result OnAtomicLoadExpr(AtomicLoadExpr*) = 0;
   130	  virtual Result OnAtomicStoreExpr(AtomicStoreExpr*) = 0;
   131	  virtual Result OnAtomicRmwExpr(AtomicRmwExpr*) = 0;
   132	  virtual Result OnAtomicRmwCmpxchgExpr(AtomicRmwCmpxchgExpr*) = 0;
   133	  virtual Result OnTernaryExpr(TernaryExpr*) = 0;
   134	  virtual Result OnSimdLaneOpExpr(SimdLaneOpExpr*) = 0;
   135	  virtual Result OnSimdLoadLaneExpr(SimdLoadLaneExpr*) = 0;
   136	  virtual Result OnSimdStoreLaneExpr(SimdStoreLaneExpr*) = 0;
   137	  virtual Result OnSimdShuffleOpExpr(SimdShuffleOpExpr*) = 0;
   138	  virtual Result OnLoadSplatExpr(LoadSplatExpr*) = 0;
   139	  virtual Result OnLoadZeroExpr(LoadZeroExpr*) = 0;
   140	};
   141	
   142	class ExprVisitor::DelegateNop : public ExprVisitor::Delegate {
   143	 public:
   144	  Result OnBinaryExpr(BinaryExpr*) override { return Result::Ok; }
   145	  Result BeginBlockExpr(BlockExpr*) override { return Result::Ok; }
   146	  Result EndBlockExpr(BlockExpr*) override { return Result::Ok; }
   147	  Result OnBrExpr(BrExpr*) override { return Result::Ok; }
   148	  Result OnBrIfExpr(BrIfExpr*) override { return Result::Ok; }
   149	  Result OnBrTableExpr(BrTableExpr*) override { return Result::Ok; }
   150	  Result OnCallExpr(CallExpr*) override { return Result::Ok; }
   151	  Result OnCallIndirectExpr(CallIndirectExpr*) override { return Result::Ok; }
   152	  Result OnCallRefExpr(CallRefExpr*) override { return Result::Ok; }
   153	  Result OnCodeMetadataExpr(CodeMetadataExpr*) override { return Result::Ok; }
   154	  Result OnCompareExpr(CompareExpr*) override { return Result::Ok; }
   155	  Result OnConstExpr(ConstExpr*) override { return Result::Ok; }
   156	  Result OnConvertExpr(ConvertExpr*) override { return Result::Ok; }
   157	  Result OnDropExpr(DropExpr*) override { return Result::Ok; }
   158	  Result OnGlobalGetExpr(GlobalGetExpr*) override { return Result::Ok; }
   159	  Result OnGlobalSetExpr(GlobalSetExpr*) override { return Result::Ok; }
   160	  Result BeginIfExpr(IfExpr*) override { return Result::Ok; }
   161	  Result AfterIfTrueExpr(IfExpr*) override { return Result::Ok; }
   162	  Result EndIfExpr(IfExpr*) override { return Result::Ok; }
   163	  Result OnLoadExpr(LoadExpr*) override { return Result::Ok; }
   164	  Result OnLocalGetExpr(LocalGetExpr*) override { return Result::Ok; }
   165	  Result OnLocalSetExpr(LocalSetExpr*) override { return Result::Ok; }
   166	  Result OnLocalTeeExpr(LocalTeeExpr*) override { return Result::Ok; }
   167	  Result BeginLoopExpr(LoopExpr*) override { return Result::Ok; }
   168	  Result EndLoopExpr(LoopExpr*) override { return Result::Ok; }
   169	  Result OnMemoryCopyExpr(MemoryCopyExpr*) override { return Result::Ok; }
   170	  Result OnDataDropExpr(DataDropExpr*) override { return Result::Ok; }
   171	  Result OnMemoryFillExpr(MemoryFillExpr*) override { return Result::Ok; }
   172	  Result OnMemoryGrowExpr(MemoryGrowExpr*) override { return Result::Ok; }
   173	  Result OnMemoryInitExpr(MemoryInitExpr*) override { return Result::Ok; }
   174	  Result OnMemorySizeExpr(MemorySizeExpr*) override { return Result::Ok; }
   175	  Result OnTableCopyExpr(TableCopyExpr*) override { return Result::Ok; }
   176	  Result OnElemDropExpr(ElemDropExpr*) override { return Result::Ok; }
   177	  Result OnTableInitExpr(TableInitExpr*) override { return Result::Ok; }
   178	  Result OnTableGetExpr(TableGetExpr*) override { return Result::Ok; }
   179	  Result OnTableSetExpr(TableSetExpr*) override { return Result::Ok; }
   180	  Result OnTableGrowExpr(TableGrowExpr*) override { return Result::Ok; }
   181	  Result OnTableSizeExpr(TableSizeExpr*) override { return Result::Ok; }
   182	  Result OnTableFillExpr(TableFillExpr*) override { return Result::Ok; }
   183	  Result OnRefFuncExpr(RefFuncExpr*) override { return Result::Ok; }
   184	  Result OnRefNullExpr(RefNullExpr*) override { return Result::Ok; }
   185	  Result OnRefIsNullExpr(RefIsNullExpr*) override { return Result::Ok; }
   186	  Result OnNopExpr(NopExpr*) override { return Result::Ok; }
   187	  Result OnReturnExpr(ReturnExpr*) override { return Result::Ok; }
   188	  Result OnReturnCallExpr(ReturnCallExpr*) override { return Result::Ok; }
   189	  Result OnReturnCallIndirectExpr(ReturnCallIndirectExpr*) override {
   190	    return Result::Ok;
   191	  }
   192	  Result OnSelectExpr(SelectExpr*) override { return Result::Ok; }
   193	  Result OnStoreExpr(StoreExpr*) override { return Result::Ok; }
   194	  Result OnUnaryExpr(UnaryExpr*) override { return Result::Ok; }
   195	  Result OnUnreachableExpr(UnreachableExpr*) override { return Result::Ok; }
   196	  Result BeginTryExpr(TryExpr*) override { return Result::Ok; }
   197	  Result OnCatchExpr(TryExpr*, Catch*) override { return Result::Ok; }
   198	  Result OnDelegateExpr(TryExpr*) override { return Result::Ok; }
   199	  Result EndTryExpr(TryExpr*) override { return Result::Ok; }
   200	  Result OnThrowExpr(ThrowExpr*) override { return Result::Ok; }
   201	  Result OnRethrowExpr(RethrowExpr*) override { return Result::Ok; }
   202	  Result OnAtomicWaitExpr(AtomicWaitExpr*) override { return Result::Ok; }
   203	  Result OnAtomicFenceExpr(AtomicFenceExpr*) override { return Result::Ok; }
   204	  Result OnAtomicNotifyExpr(AtomicNotifyExpr*) override { return Result::Ok; }
   205	  Result OnAtomicLoadExpr(AtomicLoadExpr*) override { return Result::Ok; }
   206	  Result OnAtomicStoreExpr(AtomicStoreExpr*) override { return Result::Ok; }
   207	  Result OnAtomicRmwExpr(AtomicRmwExpr*) override { return Result::Ok; }
   208	  Result OnAtomicRmwCmpxchgExpr(AtomicRmwCmpxchgExpr*) override {
   209	    return Result::Ok;
   210	  }
   211	  Result OnTernaryExpr(TernaryExpr*) override { return Result::Ok; }
   212	  Result OnSimdLaneOpExpr(SimdLaneOpExpr*) override { return Result::Ok; }
   213	  Result OnSimdLoadLaneExpr(SimdLoadLaneExpr*) override { return Result::Ok; }
   214	  Result OnSimdStoreLaneExpr(SimdStoreLaneExpr*) override { return Result::Ok; }
   215	  Result OnSimdShuffleOpExpr(SimdShuffleOpExpr*) override { return Result::Ok; }
   216	  Result OnLoadSplatExpr(LoadSplatExpr*) override { return Result::Ok; }
   217	  Result OnLoadZeroExpr(LoadZeroExpr*) override { return Result::Ok; }
   218	};
   219	
   220	}  // namespace wabt
   221	
   222	#endif  // WABT_EXPR_VISITOR_H_