Add missing samples

test/samples/sample.abap.txt

@@ -0,0 +1,29 @@
+REPORT zrosetta_base64_encode_data.
+
+DATA: li_client  TYPE REF TO if_http_client,
+      lv_encoded TYPE string,
+      lv_data    TYPE xstring.
+
+
+cl_http_client=>create_by_url(
+  EXPORTING
+    url    = 'http://rosettacode.org/favicon.ico'
+  IMPORTING
+    client = li_client ).
+
+li_client->send( ).
+li_client->receive( ).
+
+lv_data = li_client->response->get_data( ).
+
+CALL FUNCTION 'SSFC_BASE64_ENCODE'
+  EXPORTING
+    bindata = lv_data
+  IMPORTING
+    b64data = lv_encoded.
+
+WHILE strlen( lv_encoded ) > 100.
+  WRITE: / lv_encoded(100).
+  lv_encoded = lv_encoded+100.
+ENDWHILE.
+WRITE: / lv_encoded.

test/samples/sample.apex.txt

@@ -0,0 +1,7 @@
+/* Using a single database query, find all the leads in
+    the database that have the same email address as any
+    of the leads being inserted or updated. */
+for (Lead lead : [SELECT Email FROM Lead WHERE Email IN :leadMap.KeySet()]) {
+    Lead newLead = leadMap.get(lead.Email);
+    newLead.Email.addError('A lead with this email address already exists.');
+}

test/samples/sample.azcli.txt

@@ -0,0 +1,5 @@
+# Create a resource group.
+az group create --name myResourceGroup --location westeurope
+
+# Create a new virtual machine, this creates SSH keys if not present.
+az vm create --resource-group myResourceGroup --name myVM --image UbuntuLTS --generate-ssh-keys

test/samples/sample.c.txt

@@ -1,246 +1,3463 @@
-#include "pch.h"
-#include "Direct3DBase.h"
-
-using namespace Microsoft::WRL;
-using namespace Windows::UI::Core;
-using namespace Windows::Foundation;
-
-// Constructor.
-Direct3DBase::Direct3DBase()
-{
-}
-
-// Initialize the Direct3D resources required to run.
-void Direct3DBase::Initialize(CoreWindow^ window)
-{
-    m_window = window;
-    
-    CreateDeviceResources();
-    CreateWindowSizeDependentResources();
-}
-
-// These are the resources that depend on the device.
-void Direct3DBase::CreateDeviceResources()
-{
-    // This flag adds support for surfaces with a different color channel ordering than the API default.
-    // It is recommended usage, and is required for compatibility with Direct2D.
-    UINT creationFlags = D3D11_CREATE_DEVICE_BGRA_SUPPORT;
-
-#if defined(_DEBUG)
-    // If the project is in a debug build, enable debugging via SDK Layers with this flag.
-    creationFlags |= D3D11_CREATE_DEVICE_DEBUG;
-#endif
-
-    // This array defines the set of DirectX hardware feature levels this app will support.
-    // Note the ordering should be preserved.
-    // Don't forget to declare your application's minimum required feature level in its
-    // description.  All applications are assumed to support 9.1 unless otherwise stated.
-    D3D_FEATURE_LEVEL featureLevels[] = 
-    {
-        D3D_FEATURE_LEVEL_11_1,
-        D3D_FEATURE_LEVEL_11_0,
-        D3D_FEATURE_LEVEL_10_1,
-        D3D_FEATURE_LEVEL_10_0,
-        D3D_FEATURE_LEVEL_9_3,
-        D3D_FEATURE_LEVEL_9_2,
-        D3D_FEATURE_LEVEL_9_1
-    };
-
-    // Create the DX11 API device object, and get a corresponding context.
-    ComPtr<ID3D11Device> device;
-    ComPtr<ID3D11DeviceContext> context;
-    DX::ThrowIfFailed(
-        D3D11CreateDevice(
-            nullptr,                    // specify null to use the default adapter
-            D3D_DRIVER_TYPE_HARDWARE,
-            nullptr,                    // leave as nullptr unless software device
-            creationFlags,              // optionally set debug and Direct2D compatibility flags
-            featureLevels,              // list of feature levels this app can support
-            ARRAYSIZE(featureLevels),   // number of entries in above list
-            D3D11_SDK_VERSION,          // always set this to D3D11_SDK_VERSION
-            &device,                    // returns the Direct3D device created
-            &m_featureLevel,            // returns feature level of device created
-            &context                    // returns the device immediate context
-            )
-        );
-
-    // Get the DirectX11.1 device by QI off the DirectX11 one.
-    DX::ThrowIfFailed(
-        device.As(&m_d3dDevice)
-        );
-
-    // And get the corresponding device context in the same way.
-    DX::ThrowIfFailed(
-        context.As(&m_d3dContext)
-        );
-}
-
-// Allocate all memory resources that change on a window SizeChanged event.
-void Direct3DBase::CreateWindowSizeDependentResources()
-{ 
-    // Store the window bounds so the next time we get a SizeChanged event we can
-    // avoid rebuilding everything if the size is identical.
-    m_windowBounds = m_window->Bounds;
-
-    // If the swap chain already exists, resize it.
-    if(m_swapChain != nullptr)
-    {
-        DX::ThrowIfFailed(
-            m_swapChain->ResizeBuffers(2, 0, 0, DXGI_FORMAT_B8G8R8A8_UNORM, 0)
-            );
-    }
-    // Otherwise, create a new one.
-    else
-    {
-        // Create a descriptor for the swap chain.
-        DXGI_SWAP_CHAIN_DESC1 swapChainDesc = {0};
-        swapChainDesc.Width = 0;                                     // use automatic sizing
-        swapChainDesc.Height = 0;
-        swapChainDesc.Format = DXGI_FORMAT_B8G8R8A8_UNORM;           // this is the most common swapchain format
-        swapChainDesc.Stereo = false; 
-        swapChainDesc.SampleDesc.Count = 1;                          // don't use multi-sampling
-        swapChainDesc.SampleDesc.Quality = 0;
-        swapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
-        swapChainDesc.BufferCount = 2;                               // use two buffers to enable flip effect
-        swapChainDesc.Scaling = DXGI_SCALING_NONE;
-        swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL; // we recommend using this swap effect for all applications
-        swapChainDesc.Flags = 0;
-
-        // Once the desired swap chain description is configured, it must be created on the same adapter as our D3D Device
-
-        // First, retrieve the underlying DXGI Device from the D3D Device
-        ComPtr<IDXGIDevice1>  dxgiDevice;
-        DX::ThrowIfFailed(
-            m_d3dDevice.As(&dxgiDevice)
-            );
-
-        // Identify the physical adapter (GPU or card) this device is running on.
-        ComPtr<IDXGIAdapter> dxgiAdapter;
-        DX::ThrowIfFailed(
-            dxgiDevice->GetAdapter(&dxgiAdapter)
-            );
-
-        // And obtain the factory object that created it.
-        ComPtr<IDXGIFactory2> dxgiFactory;
-        DX::ThrowIfFailed(
-            dxgiAdapter->GetParent(
-                __uuidof(IDXGIFactory2), 
-                &dxgiFactory
-                )
-            );
-
-		Windows::UI::Core::CoreWindow^ p = m_window.Get();
-
-        // Create a swap chain for this window from the DXGI factory.
-        DX::ThrowIfFailed(
-            dxgiFactory->CreateSwapChainForCoreWindow(
-                m_d3dDevice.Get(),
-                reinterpret_cast<IUnknown*>(p),
-                &swapChainDesc,
-                nullptr,    // allow on all displays
-                &m_swapChain
-                )
-            );
-            
-        // Ensure that DXGI does not queue more than one frame at a time. This both reduces 
-        // latency and ensures that the application will only render after each VSync, minimizing 
-        // power consumption.
-        DX::ThrowIfFailed(
-            dxgiDevice->SetMaximumFrameLatency(1)
-            );
-    }
-    
-    // Obtain the backbuffer for this window which will be the final 3D rendertarget.
-    ComPtr<ID3D11Texture2D> backBuffer;
-    DX::ThrowIfFailed(
-        m_swapChain->GetBuffer(
-            0,
-            __uuidof(ID3D11Texture2D),
-            &backBuffer
-            )
-        );
-
-    // Create a view interface on the rendertarget to use on bind.
-    DX::ThrowIfFailed(
-        m_d3dDevice->CreateRenderTargetView(
-            backBuffer.Get(),
-            nullptr,
-            &m_renderTargetView
-            )
-        );
-
-    // Cache the rendertarget dimensions in our helper class for convenient use.
-    D3D11_TEXTURE2D_DESC backBufferDesc;
-    backBuffer->GetDesc(&backBufferDesc);
-    m_renderTargetSize.Width  = static_cast<float>(backBufferDesc.Width);
-    m_renderTargetSize.Height = static_cast<float>(backBufferDesc.Height);
-
-    // Create a descriptor for the depth/stencil buffer.
-    CD3D11_TEXTURE2D_DESC depthStencilDesc(
-        DXGI_FORMAT_D24_UNORM_S8_UINT, 
-        backBufferDesc.Width,
-        backBufferDesc.Height,
-        1,
-        1,
-        D3D11_BIND_DEPTH_STENCIL);
-
-    // Allocate a 2-D surface as the depth/stencil buffer.
-    ComPtr<ID3D11Texture2D> depthStencil;
-    DX::ThrowIfFailed(
-        m_d3dDevice->CreateTexture2D(
-            &depthStencilDesc,
-            nullptr,
-            &depthStencil
-            )
-        );
-
-    // Create a DepthStencil view on this surface to use on bind.
-    DX::ThrowIfFailed(
-        m_d3dDevice->CreateDepthStencilView(
-            depthStencil.Get(),
-            &CD3D11_DEPTH_STENCIL_VIEW_DESC(D3D11_DSV_DIMENSION_TEXTURE2D),
-            &m_depthStencilView
-            )
-        );
-
-    // Create a viewport descriptor of the full window size.
-    CD3D11_VIEWPORT viewPort(
-        0.0f,
-        0.0f,
-        static_cast<float>(backBufferDesc.Width),
-        static_cast<float>(backBufferDesc.Height)
-        );
-        
-    // Set the current viewport using the descriptor.
-    m_d3dContext->RSSetViewports(1, &viewPort);
-}
-
-void Direct3DBase::UpdateForWindowSizeChange()
-{
-    if (m_window->Bounds.Width  != m_windowBounds.Width ||
-        m_window->Bounds.Height != m_windowBounds.Height)
-    {
-        m_renderTargetView = nullptr;
-        m_depthStencilView = nullptr;
-        CreateWindowSizeDependentResources();
-    }
-}
-
-void Direct3DBase::Present()
-{
-    // The first argument instructs DXGI to block until VSync, putting the application
-    // to sleep until the next VSync. This ensures we don't waste any cycles rendering
-    // frames that will never be displayed to the screen.
-    HRESULT hr = m_swapChain->Present(1, 0);
-
-    // If the device was removed either by a disconnect or a driver upgrade, we 
-    // must completely reinitialize the renderer.
-    if (hr == DXGI_ERROR_DEVICE_REMOVED || hr == DXGI_ERROR_DEVICE_RESET)
-    {
-        Initialize(m_window.Get());
-    }
-    else
-    {
-        DX::ThrowIfFailed(hr);
+// Copyright (c) Microsoft. All rights reserved.
+// Licensed under the MIT license. See LICENSE file in the project root for full
+// license information.
+
+/*
+ *	COMMAND LINE: -Ox -Gz -YX -UPROTOTYPES_REQUIRED
+ */
+
+#pragma warning(disable : 4532)
+#pragma warning(disable : 4702)
+
+#if defined(_WIN32)
+
+#if defined(_M_SH)
+#define WIN_CE
+#endif
+
+#if defined(_M_AMD64)
+#define NEST_IN_FINALLY /* allow when __try nested in __finally OK */
+#endif
+
+#define NTSTATUS LONG
+#define EXCEPTION_NESTED_CALL 0x10
+#define RtlRaiseStatus(x) RaiseException((x), 0, 0, NULL)
+#define RtlRaiseException(x)                                                   \
+  RaiseException((x)->ExceptionCode, (x)->ExceptionFlags,                      \
+                 (x)->NumberParameters, (x)->ExceptionInformation)
+#define IN
+#define OUT
+#if !(defined(_M_IA64) || defined(_M_ALPHA) || defined(_M_PPC) ||              \
+      defined(_M_AMD64) || defined(_M_ARM) || defined(_M_ARM64))
+#define i386 1
+#endif
+#define try __try
+#define except __except
+#define finally __finally
+#define leave __leave
+
+#endif
+
+#define WIN32_LEAN_AND_MEAN
+
+#include "stdio.h"
+#if defined(_M_IA64) || defined(_M_ALPHA) || defined(_M_PPC) ||                \
+    defined(_M_AMD64) || defined(_M_ARM) || defined(_M_ARM64)
+#include "setjmpex.h"
+#else
+#include "setjmp.h"
+#endif
+#include "float.h"
+#include "windows.h"
+#include "math.h"
+
+#if !defined(STATUS_SUCCESS)
+#define STATUS_SUCCESS 0
+#endif
+#if !defined(STATUS_UNSUCCESSFUL)
+#define STATUS_UNSUCCESSFUL ((NTSTATUS)0xC0000001L)
+#endif
+
+//
+// Define switch constants.
+//
+
+#define BLUE 0
+#define RED 1
+
+//
+// Define function prototypes.
+//
+
+VOID addtwo(IN LONG First, IN LONG Second, IN PLONG Place);
+
+VOID bar1(IN NTSTATUS Status, IN PLONG Counter);
+
+VOID bar2(IN PLONG BlackHole, IN PLONG BadAddress, IN PLONG Counter);
+
+VOID dojump(IN jmp_buf JumpBuffer, IN PLONG Counter);
+
+LONG Echo(IN LONG Value);
+
+#if !defined(WIN_CE) // return through finally not allowed on WinCE
+VOID eret(IN NTSTATUS Status, IN PLONG Counter);
+#endif
+
+VOID except1(IN PLONG Counter);
+
+ULONG
+except2(IN PEXCEPTION_POINTERS ExceptionPointers, IN PLONG Counter);
+
+ULONG
+except3(IN PEXCEPTION_POINTERS ExceptionPointers, IN PLONG Counter);
+
+VOID foo1(IN NTSTATUS Status);
+
+VOID foo2(IN PLONG BlackHole, IN PLONG BadAddress);
+
+#if !defined(WIN_CE) // return from finally not allowed on WinCE
+VOID fret(IN PLONG Counter);
+#endif
+
+BOOLEAN
+Tkm(VOID);
+
+VOID Test61Part2(IN OUT PULONG Counter);
+
+double SquareDouble(IN double op);
+
+DECLSPEC_NOINLINE
+ULONG
+PgFilter(VOID)
+
+{
+
+  printf("filter entered...");
+  return EXCEPTION_EXECUTE_HANDLER;
+}
+
+#pragma warning(push)
+#pragma warning(disable : 4532)
+
+VOID PgTest69(IN PLONG State, IN PLONG Fault)
+
+{
+
+  try {
+    try {
+      *Fault += 1;
+    }
+    finally {
+      if (AbnormalTermination()) {
+        if (*State == 1) {
+          *State += 1;
+
+        } else {
+          *Fault += 1;
+        }
+      }
+    }
+  }
+  except(((*State += 1) == 1) ? PgFilter() : EXCEPTION_CONTINUE_SEARCH) {
+    if (*State != 2) {
+      *Fault += 1;
+    }
+  }
+
+  return;
+}
+
+VOID PgTest70(IN PLONG State, IN PLONG Fault)
+
+{
+
+  try {
+    try {
+      *Fault += 1;
+    }
+    finally {
+      if (AbnormalTermination()) {
+        if (*State == 2) {
+          PgFilter();
+          return;
+
+        } else {
+          *Fault += 1;
+        }
+      }
+    }
+  }
+  except(((*State += 2) == 2) ? EXCEPTION_EXECUTE_HANDLER
+                              : EXCEPTION_CONTINUE_SEARCH) {
+    *Fault += 1;
+  }
+
+  return;
+}
+
+VOID PgTest71(IN PLONG State, IN PLONG Fault)
+
+{
+
+  try {
+    try {
+      try {
+        *Fault += 1;
+      }
+      finally {
+        if (AbnormalTermination()) {
+          if (*State == 3) {
+            *State += 3;
+            return;
+
+          } else {
+            *Fault += 1;
+          }
+        }
+      }
+    }
+    finally {
+      if (AbnormalTermination()) {
+        if (*State == 6) {
+          *State += 3;
+
+        } else {
+          *Fault += 1;
+        }
+      }
+    }
+  }
+  except(((*State += 3) == 3) ? PgFilter() : EXCEPTION_CONTINUE_SEARCH) {
+    *Fault += 1;
+  }
+
+  return;
+}
+
+VOID PgTest72(IN PLONG State, IN PLONG Fault)
+
+{
+
+  try {
+    try {
+      try {
+        *Fault += 1;
+      }
+      finally {
+        if (AbnormalTermination()) {
+          if (*State == 4) {
+            *State += 4;
+            return;
+
+          } else {
+            *Fault += 1;
+          }
+        }
+      }
+    }
+    finally {
+      if (AbnormalTermination()) {
+        if (*State == 8) {
+          *State += 4;
+          PgFilter();
+
+        } else {
+          *Fault += 1;
+        }
+      }
+    }
+  }
+  except(((*State += 4) == 4) ? EXCEPTION_EXECUTE_HANDLER
+                              : EXCEPTION_CONTINUE_SEARCH) {
+    *Fault += 1;
+  }
+
+  return;
+}
+
+VOID PgTest73(IN PLONG State, IN PLONG Fault)
+
+{
+
+  try {
+    try {
+      try {
+        *Fault += 1;
+      }
+      finally {
+        if (AbnormalTermination()) {
+          if (*State == 5) {
+            *State += 5;
+
+          } else {
+            *Fault += 1;
+          }
+        }
+      }
+    }
+    finally {
+      if (AbnormalTermination()) {
+        if (*State == 10) {
+          *State += 5;
+          return;
+
+        } else {
+          *Fault += 1;
+        }
+      }
+    }
+  }
+  except(((*State += 5) == 5) ? PgFilter() : EXCEPTION_CONTINUE_SEARCH) {
+    *Fault += 1;
+  }
+
+  return;
+}
+
+VOID PgTest74(IN PLONG State, IN PLONG Fault)
+
+{
+
+  try {
+    try {
+      try {
+        *Fault += 1;
+      }
+      finally {
+        if (AbnormalTermination()) {
+          if (*State == 6) {
+            *State += 6;
+
+          } else {
+            *Fault += 1;
+          }
+        }
+      }
+    }
+    finally {
+      if (AbnormalTermination()) {
+        if (*State == 12) {
+          *State += 6;
+          PgFilter();
+          return;
+
+        } else {
+          *Fault += 1;
+        }
+      }
+    }
+  }
+  except(((*State += 6) == 6) ? EXCEPTION_EXECUTE_HANDLER
+                              : EXCEPTION_CONTINUE_SEARCH) {
+    *Fault += 1;
+  }
+
+  return;
+}
+
+VOID PgTest75(IN PLONG State, IN PLONG Fault)
+
+{
+
+  try {
+    try {
+      try {
+        try {
+          *Fault += 1;
+        }
+        finally {
+          if (AbnormalTermination()) {
+            if (*State == 7) {
+              *State += 7;
+              *Fault += 1;
+
+            } else {
+              *State += 10;
+            }
+          }
+        }
+      }
+      except(((*State += 7) == 7) ? EXCEPTION_EXECUTE_HANDLER
+                                  : EXCEPTION_CONTINUE_SEARCH) {
+        *Fault += 1;
+      }
+    }
+    finally {
+      if (AbnormalTermination()) {
+        if (*State == 28) {
+          *State += 7;
+          return;
+
+        } else {
+          *Fault += 1;
+        }
+      }
+    }
+  }
+  except(((*State += 7) == 28) ? PgFilter() : EXCEPTION_CONTINUE_SEARCH) {
+    *Fault += 1;
+  }
+
+  return;
+}
+
+VOID PgTest76(IN PLONG State, IN PLONG Fault)
+
+{
+
+  try {
+    try {
+      try {
+        try {
+          *Fault += 1;
+        }
+        finally {
+          if (AbnormalTermination()) {
+            if (*State == 8) {
+              *State += 8;
+              *Fault += 1;
+
+            } else {
+              *State += 10;
+            }
+          }
+        }
+      }
+      except(((*State += 8) == 8) ? EXCEPTION_EXECUTE_HANDLER
+                                  : EXCEPTION_CONTINUE_SEARCH) {
+        *Fault += 1;
+      }
+    }
+    finally {
+      if (AbnormalTermination()) {
+        if (*State == 32) {
+          *State += 8;
+          PgFilter();
+          return;
+
+        } else {
+          *Fault += 1;
+        }
+      }
+    }
+  }
+  except(((*State += 8) == 32) ? EXCEPTION_EXECUTE_HANDLER
+                               : EXCEPTION_CONTINUE_SEARCH) {
+    *Fault += 1;
+  }
+
+  return;
+}
+
+VOID PgTest77(IN PLONG State, IN PLONG Fault)
+
+{
+
+  try {
+    try {
+      try {
+        try {
+          *Fault += 1;
+        }
+        finally {
+          if (AbnormalTermination()) {
+            if (*State == 9) {
+              *State += 9;
+              *Fault += 1;
+
+            } else {
+              *State += 10;
+            }
+          }
+        }
+      }
+      except(((*State += 9) == 9) ? PgFilter() : EXCEPTION_CONTINUE_SEARCH) {
+        *Fault += 1;
+      }
+    }
+    finally {
+      if (AbnormalTermination()) {
+        if (*State == 36) {
+          *State += 9;
+          return;
+
+        } else {
+          *Fault += 1;
+        }
+      }
+    }
+  }
+  except(((*State += 9) == 36) ? EXCEPTION_EXECUTE_HANDLER
+                               : EXCEPTION_CONTINUE_SEARCH) {
+    *Fault += 1;
+  }
+
+  return;
+}
+
+VOID PgTest78(IN PLONG State, IN PLONG Fault)
+
+{
+
+  try {
+    try {
+      try {
+        try {
+          *Fault += 1;
+        }
+        finally {
+          if (AbnormalTermination()) {
+            if (*State == 10) {
+              *State += 10;
+              PgFilter();
+              *Fault += 1;
+
+            } else {
+              *State += 10;
+            }
+          }
+        }
+      }
+      except(((*State += 10) == 10) ? EXCEPTION_EXECUTE_HANDLER
+                                    : EXCEPTION_CONTINUE_SEARCH) {
+        *Fault += 1;
+      }
+    }
+    finally {
+      if (AbnormalTermination()) {
+        if (*State == 40) {
+          *State += 10;
+          return;
+
+        } else {
+          *Fault += 1;
+        }
+      }
+    }
+  }
+  except(((*State += 10) == 40) ? EXCEPTION_EXECUTE_HANDLER
+                                : EXCEPTION_CONTINUE_SEARCH) {
+    *Fault += 1;
+  }
+
+  return;
+}
+
+#pragma warning(pop)
+
+VOID Test79(PLONG Counter, PLONG Fault)
+
+{
+
+  try {
+    try {
+      try {
+        *Fault += 1;
+      }
+      finally {
+        printf("finally 1...");
+        *Fault += 1;
+      }
+    }
+    finally { printf("finally 2..."); }
+  }
+  except(*Counter += 1, printf("filter 1..."), EXCEPTION_CONTINUE_SEARCH) {}
+
+  return;
+}
+
+ULONG G;
+
+ULONG
+Test80(VOID)
+
+{
+
+  G = 1;
+  try {
+    while (G) {
+      try {
+        if (G == 10) {
+          return 1;
+        }
+
+        if (G == 1) {
+          continue;
+        }
+      }
+      finally { G = 0; }
+    }
+  }
+  finally { G = 10; }
+
+  return 0;
+}
+
+void Test81(int *pCounter) {
+  volatile char *AvPtr = NULL;
+
+  __try {
+    __try { *AvPtr = '\0'; }
+    __except(EXCEPTION_EXECUTE_HANDLER) { __leave; }
+  }
+  __finally {
+    printf("in finally ");
+    *pCounter += 1;
+  }
+  return;
+}
+
+DECLSPEC_NOINLINE
+VOID Test82Foo(VOID)
+
+{
+  *(volatile int *)0 = 0;
+}
+
+VOID Test82(__inout PLONG Counter)
+
+{
+
+  int retval = 1;
+
+  __try {
+    __try { Test82Foo(); }
+    __finally {
+      switch (*Counter) {
+      case 0:
+        printf("something failed!\n");
+        retval = 6;
+        break;
+
+      case 1:
+        retval = 0;
+        break;
+
+      case 2:
+        printf("how did you get here?\n");
+        retval = 2;
+        break;
+
+      case 3:
+        printf("what?!?\n");
+        retval = 3;
+        break;
+
+      case 4:
+        printf("not correct\n");
+        retval = 4;
+        break;
+
+      case 5:
+        printf("error!\n");
+        retval = 5;
+        break;
+      }
+    }
+  }
+  __except(1){}
+
+  *Counter = retval;
+  return;
+}
+
+LONG Test83(VOID)
+
+{
+
+  G = 1;
+  try {
+    try {
+      while (G) {
+        try {
+          if (G == 10) {
+            return 1;
+          }
+
+          if (G == 1) {
+            continue;
+          }
+        }
+        finally { G = 0; }
+      }
+    }
+    except(EXCEPTION_EXECUTE_HANDLER) { leave; }
+  }
+  finally { G = 10; }
+
+  return 0;
+}
+
+DECLSPEC_NOINLINE
+VOID Test84(_Inout_ PLONG Counter)
+
+{
+  volatile int *Fault = 0;
+
+  try {
+    try {
+      *Fault += 1;
+    }
+    except(EXCEPTION_EXECUTE_HANDLER) {
+      try {
+        return;
+      }
+      finally { *Counter += 1; }
+    }
+  }
+  finally {
+
+    if (AbnormalTermination()) {
+      *Counter += 1;
+    }
+  }
+
+  return;
+}
+
+DECLSPEC_NOINLINE
+LONG Test85(_Inout_ PLONG Counter)
+
+{
+  volatile int *Fault = 0;
+
+  G = 1;
+  try {
+    try {
+      try {
+        while (G) {
+          try {
+            try {
+              if (G == 10) {
+                return 1;
+              }
+              try {
+                *Counter += 1;
+              }
+              except(EXCEPTION_EXECUTE_HANDLER) {}
+
+              if (G == 1) {
+                continue;
+              }
+            }
+            finally {
+              G = 0;
+              *Counter += 1;
+              *Fault += 1;
+            }
+          }
+          except(EXCEPTION_EXECUTE_HANDLER) {
+            *Counter += 1;
+            leave;
+          }
+        }
+      }
+      finally {
+        G = 10;
+        *Counter += 1;
+        *Fault += 1;
+      }
+    }
+    except(EXCEPTION_EXECUTE_HANDLER) { *Counter += 1; }
+    *Counter += 1;
+  }
+  finally { *Counter += 1; }
+  return 1;
+}
+
+DECLSPEC_NOINLINE
+VOID Test86(_Inout_ PLONG Counter)
+
+{
+  volatile int *Fault = 0;
+
+  try {
+    try {
+      try {
+        try {
+          try {
+            try {
+              *Fault += 1;
+            }
+            except(printf("Filter1 %d..", *Counter),
+                   EXCEPTION_EXECUTE_HANDLER) {
+              try {
+                printf("Handler1 %d..", *Counter);
+                return;
+              }
+              finally {
+                printf("Finally1 %d..", *Counter);
+                *Counter += 1;
+              }
+            }
+          }
+          finally {
+            printf("Finally2 %d..", *Counter);
+            *Counter += 1;
+          }
+        }
+        except(EXCEPTION_EXECUTE_HANDLER) { leave; }
+      }
+      finally { *Counter += 1; }
+    }
+    except(EXCEPTION_EXECUTE_HANDLER) { leave; }
+  }
+  finally { *Counter += 1; }
+
+  return;
+}
+
+VOID Test87(_Inout_ PLONG Counter)
+
+/*++
+
+Routine Description:
+
+    This function verifies the behavior of nested exception dispatching.
+
+Arguments:
+
+    Counter - Supplies a pointer to the state counter.
+
+Return Value:
+    None.
+
+--*/
+
+{
+  volatile int *Fault = 0;
+
+//
+// N.B.  Disabled on x86 due to failing test case with handling of returns
+//       in nested termination handlers on x86.
+//
+//       Disabled on ARM due to failing test case with handling of abutting
+//       termination handlers within an except handler.
+//
+//       Disabled on AMD64 due to failing test case with handling of
+//       abutting termination handlers within an except handler when a
+//       non-local goto is involved.
+//
+
+#if !defined(_X86_)
+  try {
+    try {
+      try {
+        try {
+          try {
+            *Fault += 1;
+
+            try {
+            }
+            finally {
+              if (AbnormalTermination()) {
+                *Fault += 1;
+              }
+            }
+          }
+          finally {
+
+            if (AbnormalTermination()) {
+              if ((*Counter += 13) == 26) {
+                return;
+
+              } else {
+                *Fault += 1;
+              }
+            }
+          }
+        }
+        finally {
+          if (AbnormalTermination()) {
+            *Counter += 13;
+            *Fault += 1;
+          }
+        }
+      }
+      except(((*Counter += 13) == 13) ? EXCEPTION_EXECUTE_HANDLER
+                                      : EXCEPTION_CONTINUE_SEARCH) {
+        *Fault += 1;
+      }
+    }
+    except(((*Counter += 13) == 65) ? EXCEPTION_EXECUTE_HANDLER
+                                    : EXCEPTION_CONTINUE_SEARCH) {
+      try {
+        *Counter += 13;
+        return;
+      }
+      finally {
+        if (AbnormalTermination()) {
+          *Counter += 13;
+          goto Finish;
+        }
+      }
+    }
+  }
+  finally {
+
+    if (AbnormalTermination()) {
+      if ((*Counter += 13) == 104) {
+        goto Finish;
+      }
+    }
+  }
+
+Finish:
+#else
+  *Counter = 104;
+#endif
+
+  return;
+}
+
+VOID Test88(_Inout_ PLONG Counter)
+
+{
+  volatile int *Fault = 0;
+
+  try {
+    try {
+      try {
+        try {
+          try {
+            try {
+              try {
+                try {
+                  *Fault += 1;
+                }
+                except(((*Counter += 1) == 1) ? *Fault
+                                              : EXCEPTION_CONTINUE_SEARCH) {}
+              }
+              except(*Counter += 1, EXCEPTION_EXECUTE_HANDLER) { *Fault += 2; }
+            }
+            except(*Counter += 1, EXCEPTION_CONTINUE_SEARCH) { leave; }
+          }
+          except(*Counter += 1, EXCEPTION_CONTINUE_SEARCH) { leave; }
+        }
+        except(EXCEPTION_EXECUTE_HANDLER) {}
+      }
+      except(EXCEPTION_EXECUTE_HANDLER) {}
+    }
+    except(EXCEPTION_EXECUTE_HANDLER) { leave; }
+  }
+  finally { *Counter += 1; }
+}
+
+int main(int argc, char *argv[])
+
+{
+
+  PLONG BadAddress;
+  PCHAR BadByte;
+  PLONG BlackHole;
+  ULONG Index1;
+  ULONG Index2 = RED;
+  jmp_buf JumpBuffer;
+  LONG Counter;
+  EXCEPTION_RECORD ExceptionRecord;
+  double doubleresult;
+
+  //
+  // Announce start of exception test.
+  //
+
+  printf("Start of exception test\n");
+
+  //
+  // Initialize exception record.
+  //
+
+  ExceptionRecord.ExceptionCode = STATUS_INTEGER_OVERFLOW;
+  ExceptionRecord.ExceptionFlags = 0;
+  ExceptionRecord.ExceptionRecord = NULL;
+  ExceptionRecord.NumberParameters = 0;
+
+  //
+  // Initialize pointers.
+  //
+
+  BadAddress = (PLONG)NULL;
+  BadByte = (PCHAR)NULL;
+  BadByte += 1;
+  BlackHole = &Counter;
+
+  //
+  // Simply try statement with a finally clause that is entered sequentially.
+  //
+
+  printf("    test1...");
+  Counter = 0;
+  try {
+    Counter += 1;
+  }
+  finally {
+    if (abnormal_termination() == FALSE) {
+      Counter += 1;
+    }
+  }
+
+  if (Counter != 2) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Simple try statement with an exception clause that is never executed
+  // because there is no exception raised in the try clause.
+  //
+
+  printf("    test2...");
+  Counter = 0;
+  try {
+    Counter += 1;
+  }
+  except(Counter) { Counter += 1; }
+
+  if (Counter != 1) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Simple try statement with an exception handler that is never executed
+  // because the exception expression continues execution.
+  //
+
+  printf("    test3...");
+  Counter = 0;
+  try {
+    Counter -= 1;
+    RtlRaiseException(&ExceptionRecord);
+  }
+  except(Counter) { Counter -= 1; }
+
+  if (Counter != -1) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Simple try statement with an exception clause that is always executed.
+  //
+
+  printf("    test4...");
+  Counter = 0;
+  try {
+    Counter += 1;
+    RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
+  }
+  except(Counter) { Counter += 1; }
+
+  if (Counter != 2) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Simple try statement with an exception clause that is always executed.
+  //
+
+  printf("    test5...");
+  Counter = 0;
+  try {
+    Counter += 1;
+    *BlackHole += *BadAddress;
+  }
+  except(Counter) { Counter += 1; }
+
+  if (Counter != 2) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Simply try statement with a finally clause that is entered as the
+  // result of an exception.
+  //
+
+  printf("    test6...");
+  Counter = 0;
+  try {
+    try {
+      Counter += 1;
+      RtlRaiseException(&ExceptionRecord);
+    }
+    finally {
+      if (abnormal_termination() != FALSE) {
+        Counter += 1;
+      }
+    }
+  }
+  except(Counter) {
+    if (Counter == 2) {
+      Counter += 1;
+    }
+  }
+
+  if (Counter != 3) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Simply try statement with a finally clause that is entered as the
+  // result of an exception.
+  //
+
+  printf("    test7...");
+  Counter = 0;
+  try {
+    try {
+      Counter += 1;
+      *BlackHole += *BadAddress;
+    }
+    finally {
+      if (abnormal_termination() != FALSE) {
+        Counter += 1;
+      }
+    }
+  }
+  except(Counter) {
+    if (Counter == 2) {
+      Counter += 1;
+    }
+  }
+
+  if (Counter != 3) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Simple try that calls a function which raises an exception.
+  //
+
+  printf("    test8...");
+  Counter = 0;
+  try {
+    Counter += 1;
+    foo1(STATUS_ACCESS_VIOLATION);
+  }
+  except((GetExceptionCode() == STATUS_ACCESS_VIOLATION)
+             ? EXCEPTION_EXECUTE_HANDLER
+             : EXCEPTION_CONTINUE_SEARCH) {
+    Counter += 1;
+  }
+
+  if (Counter != 2) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Simple try that calls a function which raises an exception.
+  //
+
+  printf("    test9...");
+  Counter = 0;
+  try {
+    Counter += 1;
+    foo2(BlackHole, BadAddress);
+  }
+  except((GetExceptionCode() == STATUS_ACCESS_VIOLATION)
+             ? EXCEPTION_EXECUTE_HANDLER
+             : EXCEPTION_CONTINUE_SEARCH) {
+    Counter += 1;
+  }
+
+  if (Counter != 2) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Simple try that calls a function which calls a function that
+  // raises an exception. The first function has a finally clause
+  // that must be executed for this test to work.
+  //
+
+  printf("    test10...");
+  Counter = 0;
+  try {
+    bar1(STATUS_ACCESS_VIOLATION, &Counter);
+  }
+  except((GetExceptionCode() == STATUS_ACCESS_VIOLATION)
+             ? EXCEPTION_EXECUTE_HANDLER
+             : EXCEPTION_CONTINUE_SEARCH) {
+    Counter -= 1;
+  }
+
+  if (Counter != 98) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Simple try that calls a function which calls a function that
+  // raises an exception. The first function has a finally clause
+  // that must be executed for this test to work.
+  //
+
+  printf("    test11...");
+  Counter = 0;
+  try {
+    bar2(BlackHole, BadAddress, &Counter);
+  }
+  except((GetExceptionCode() == STATUS_ACCESS_VIOLATION)
+             ? EXCEPTION_EXECUTE_HANDLER
+             : EXCEPTION_CONTINUE_SEARCH) {
+    Counter -= 1;
+  }
+
+  if (Counter != 98) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // A try within an except
+  //
+
+  printf("    test12...");
+  Counter = 0;
+  try {
+    foo1(STATUS_ACCESS_VIOLATION);
+  }
+  except((GetExceptionCode() == STATUS_ACCESS_VIOLATION)
+             ? EXCEPTION_EXECUTE_HANDLER
+             : EXCEPTION_CONTINUE_SEARCH) {
+    Counter += 1;
+    try {
+      foo1(STATUS_SUCCESS);
+    }
+    except((GetExceptionCode() == STATUS_SUCCESS) ? EXCEPTION_EXECUTE_HANDLER
+                                                  : EXCEPTION_CONTINUE_SEARCH) {
+      if (Counter != 1) {
+        printf("failed, count = %d\n", Counter);
+
+      } else {
+        printf("succeeded...");
+      }
+
+      Counter += 1;
+    }
+  }
+
+  if (Counter != 2) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // A try within an except
+  //
+
+  printf("    test13...");
+  Counter = 0;
+  try {
+    foo2(BlackHole, BadAddress);
+  }
+  except((GetExceptionCode() == STATUS_ACCESS_VIOLATION)
+             ? EXCEPTION_EXECUTE_HANDLER
+             : EXCEPTION_CONTINUE_SEARCH) {
+    Counter += 1;
+    try {
+      foo1(STATUS_SUCCESS);
+    }
+    except((GetExceptionCode() == STATUS_SUCCESS) ? EXCEPTION_EXECUTE_HANDLER
+                                                  : EXCEPTION_CONTINUE_SEARCH) {
+      if (Counter != 1) {
+        printf("failed, count = %d\n", Counter);
+
+      } else {
+        printf("succeeded...");
+      }
+
+      Counter += 1;
+    }
+  }
+
+  if (Counter != 2) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+#if !defined(WIN_CE) // gotos from except/finally not allowed on WinCE
+  //
+  // A goto from an exception clause that needs to pass
+  // through a finally
+  //
+
+  printf("    test14...");
+  Counter = 0;
+  try {
+    try {
+      foo1(STATUS_ACCESS_VIOLATION);
+    }
+    except((GetExceptionCode() == STATUS_ACCESS_VIOLATION)
+               ? EXCEPTION_EXECUTE_HANDLER
+               : EXCEPTION_CONTINUE_SEARCH) {
+      Counter += 1;
+      goto t9;
+    }
+  }
+  finally { Counter += 1; }
+
+t9:
+  ;
+  if (Counter != 2) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // A goto from an finally clause that needs to pass
+  // through a finally
+  //
+
+  printf("    test15...");
+  Counter = 0;
+  try {
+    try {
+      Counter += 1;
+    }
+    finally {
+      Counter += 1;
+      goto t10;
+    }
+  }
+  finally { Counter += 1; }
+
+t10:
+  ;
+  if (Counter != 3) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // A goto from an exception clause that needs to pass
+  // through a finally into the outer finally clause.
+  //
+
+  printf("    test16...");
+  Counter = 0;
+  try {
+    try {
+      try {
+        Counter += 1;
+        foo1(STATUS_INTEGER_OVERFLOW);
+      }
+      except(EXCEPTION_EXECUTE_HANDLER) {
+        Counter += 1;
+        goto t11;
+      }
+    }
+    finally { Counter += 1; }
+  t11:
+    ;
+  }
+  finally { Counter += 1; }
+
+  if (Counter != 4) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // A goto from an finally clause that needs to pass
+  // through a finally into the outer finally clause.
+  //
+
+  printf("    test17...");
+  Counter = 0;
+  try {
+    try {
+      Counter += 1;
+    }
+    finally {
+      Counter += 1;
+      goto t12;
+    }
+  t12:
+    ;
+  }
+  finally { Counter += 1; }
+
+  if (Counter != 3) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // A return from an except clause
+  //
+
+  printf("    test18...");
+  Counter = 0;
+  try {
+    Counter += 1;
+    eret(STATUS_ACCESS_VIOLATION, &Counter);
+  }
+  finally { Counter += 1; }
+
+  if (Counter != 4) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // A return from a finally clause
+  //
+
+  printf("    test19...");
+  Counter = 0;
+  try {
+    Counter += 1;
+    fret(&Counter);
+  }
+  finally { Counter += 1; }
+
+  if (Counter != 5) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+#endif
+
+  //
+  // A simple set jump followed by a long jump.
+  //
+
+  printf("    test20...");
+  Counter = 0;
+  if (setjmp(JumpBuffer) == 0) {
+    Counter += 1;
+    longjmp(JumpBuffer, 1);
+
+  } else {
+    Counter += 1;
+  }
+
+  if (Counter != 2) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // A set jump followed by a long jump out of a finally clause that is
+  // sequentially executed.
+  //
+
+  printf("    test21...");
+  Counter = 0;
+  if (setjmp(JumpBuffer) == 0) {
+    try {
+      Counter += 1;
+    }
+    finally {
+      Counter += 1;
+      longjmp(JumpBuffer, 1);
+    }
+
+  } else {
+    Counter += 1;
+  }
+
+  if (Counter != 3) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // A set jump within a try clause followed by a long jump out of a
+  // finally clause that is sequentially executed.
+  //
+
+  printf("    test22...");
+  Counter = 0;
+  try {
+    if (setjmp(JumpBuffer) == 0) {
+      Counter += 1;
+
+    } else {
+      Counter += 1;
+    }
+  }
+  finally {
+    Counter += 1;
+    if (Counter == 2) {
+      Counter += 1;
+      longjmp(JumpBuffer, 1);
+    }
+  }
+
+  if (Counter != 5) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // A set jump followed by a try/except, followed by a try/finally where
+  // the try body of the try/finally raises an exception that is handled
+  // by the try/excecpt which causes the try/finally to do a long jump out
+  // of a finally clause. This will create a collided unwind.
+  //
+
+  printf("    test23...");
+  Counter = 0;
+  if (setjmp(JumpBuffer) == 0) {
+    try {
+      try {
+        Counter += 1;
+        RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
+      }
+      finally {
+        Counter += 1;
+        longjmp(JumpBuffer, 1);
+      }
+    }
+    except(EXCEPTION_EXECUTE_HANDLER) { Counter += 1; }
+
+  } else {
+    Counter += 1;
+  }
+
+  if (Counter != 3) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // A set jump followed by a try/except, followed by a several nested
+  // try/finally's where the inner try body of the try/finally raises an
+  // exception that is handled by the try/except which causes the
+  // try/finally to do a long jump out of a finally clause. This will
+  // create a collided unwind.
+  //
+
+  printf("    test24...");
+  Counter = 0;
+  if (setjmp(JumpBuffer) == 0) {
+    try {
+      try {
+        try {
+          try {
+            Counter += 1;
+            RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
+          }
+          finally { Counter += 1; }
+        }
+        finally {
+          Counter += 1;
+          longjmp(JumpBuffer, 1);
+        }
+      }
+      finally { Counter += 1; }
+    }
+    except(EXCEPTION_EXECUTE_HANDLER) { Counter += 1; }
+
+  } else {
+    Counter += 1;
+  }
+
+  if (Counter != 5) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // A set jump followed by a try/except, followed by a try/finally which
+  // calls a subroutine which contains a try finally that raises an
+  // exception that is handled to the try/except.
+  //
+
+  printf("    test25...");
+  Counter = 0;
+  if (setjmp(JumpBuffer) == 0) {
+    try {
+      try {
+        try {
+          Counter += 1;
+          dojump(JumpBuffer, &Counter);
+        }
+        finally { Counter += 1; }
+      }
+      finally { Counter += 1; }
+    }
+    except(EXCEPTION_EXECUTE_HANDLER) { Counter += 1; }
+
+  } else {
+    Counter += 1;
+  }
+
+  if (Counter != 7) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // A set jump followed by a try/except, followed by a try/finally which
+  // calls a subroutine which contains a try finally that raises an
+  // exception that is handled to the try/except.
+  //
+
+  printf("    test26...");
+  Counter = 0;
+  if (setjmp(JumpBuffer) == 0) {
+    try {
+      try {
+        try {
+          try {
+            Counter += 1;
+            dojump(JumpBuffer, &Counter);
+          }
+          finally { Counter += 1; }
+        }
+        finally {
+          Counter += 1;
+          longjmp(JumpBuffer, 1);
+        }
+      }
+      finally { Counter += 1; }
+    }
+    except(EXCEPTION_EXECUTE_HANDLER) { Counter += 1; }
+
+  } else {
+    Counter += 1;
+  }
+
+  if (Counter != 8) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Test nested exceptions.
+  //
+
+  printf("    test27...");
+  Counter = 0;
+  try {
+    try {
+      Counter += 1;
+      except1(&Counter);
+    }
+    except(except2(GetExceptionInformation(), &Counter)) { Counter += 2; }
+  }
+  except(EXCEPTION_EXECUTE_HANDLER) { Counter += 3; }
+
+  if (Counter != 55) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Simple try that causes an integer overflow exception.
+  //
+
+  printf("    test28...");
+  Counter = 0;
+  try {
+    Counter += 1;
+    addtwo(0x7fff0000, 0x10000, &Counter);
+  }
+  except((GetExceptionCode() == STATUS_INTEGER_OVERFLOW)
+             ? EXCEPTION_EXECUTE_HANDLER
+             : EXCEPTION_CONTINUE_SEARCH) {
+    Counter += 1;
+  }
+
+  if (Counter != 2) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+//
+// Simple try that raises an misaligned data exception.
+//
+#if !defined(i386) && !defined(_M_IA64) && !defined(_M_AMD64) &&               \
+    !defined(_M_ARM) && !defined(_M_ARM64)
+  printf("    test29...");
+  Counter = 0;
+  try {
+    Counter += 1;
+    foo2(BlackHole, (PLONG)BadByte);
+  }
+  except((GetExceptionCode() == STATUS_DATATYPE_MISALIGNMENT)
+             ? EXCEPTION_EXECUTE_HANDLER
+             : EXCEPTION_CONTINUE_SEARCH) {
+    Counter += 1;
+  }
+
+  if (Counter != 2) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+#endif
+  //
+  // Continue from a try body with an exception clause in a loop.
+  //
+
+  printf("    test30...");
+  Counter = 0;
+  for (Index1 = 0; Index1 < 10; Index1 += 1) {
+    try {
+      if ((Index1 & 0x1) == 0) {
+        continue;
+
+      } else {
+        Counter += 1;
+      }
+    }
+    except(EXCEPTION_EXECUTE_HANDLER) { Counter += 40; }
+
+    Counter += 2;
+  }
+
+  if (Counter != 15) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+#if !defined(WIN_CE) // gotos from try/finally not allowed on WinCE
+  //
+  // Continue from a try body with an finally clause in a loop.
+  //
+
+  printf("    test31...");
+  Counter = 0;
+  for (Index1 = 0; Index1 < 10; Index1 += 1) {
+    try {
+      if ((Index1 & 0x1) == 0) {
+        continue;
+
+      } else {
+        Counter += 1;
+      }
+    }
+    finally { Counter += 2; }
+
+    Counter += 3;
+  }
+
+  if (Counter != 40) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+#endif
+
+  //
+  // Continue from doubly nested try body with an exception clause in a
+  // loop.
+  //
+
+  printf("    test32...");
+  Counter = 0;
+  for (Index1 = 0; Index1 < 10; Index1 += 1) {
+    try {
+      try {
+        if ((Index1 & 0x1) == 0) {
+          continue;
+
+        } else {
+          Counter += 1;
+        }
+      }
+      except(EXCEPTION_EXECUTE_HANDLER) { Counter += 10; }
+
+      Counter += 2;
+    }
+    except(EXCEPTION_EXECUTE_HANDLER) { Counter += 20; }
+
+    Counter += 3;
+  }
+
+  if (Counter != 30) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+#if !defined(WIN_CE) // gotos from try/finally not allowed on WinCE
+  //
+  // Continue from doubly nested try body with an finally clause in a loop.
+  //
+
+  printf("    test33...");
+  Counter = 0;
+  for (Index1 = 0; Index1 < 10; Index1 += 1) {
+    try {
+      try {
+        if ((Index1 & 0x1) == 0) {
+          continue;
+
+        } else {
+          Counter += 1;
+        }
+      }
+      finally { Counter += 2; }
+
+      Counter += 3;
+    }
+    finally { Counter += 4; }
+
+    Counter += 5;
+  }
+
+  if (Counter != 105) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Continue from a finally clause in a loop.
+  //
+
+  printf("    test34...");
+  Counter = 0;
+  for (Index1 = 0; Index1 < 10; Index1 += 1) {
+    try {
+      if ((Index1 & 0x1) == 0) {
+        Counter += 1;
+      }
+    }
+    finally {
+      Counter += 2;
+      continue;
+    }
+
+    Counter += 4;
+  }
+
+  if (Counter != 25) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Continue from a doubly nested finally clause in a loop.
+  //
+
+  printf("    test35...");
+  Counter = 0;
+  for (Index1 = 0; Index1 < 10; Index1 += 1) {
+    try {
+      try {
+        if ((Index1 & 0x1) == 0) {
+          Counter += 1;
+        }
+      }
+      finally {
+        Counter += 2;
+        continue;
+      }
+
+      Counter += 4;
+    }
+    finally { Counter += 5; }
+
+    Counter += 6;
+  }
+
+  if (Counter != 75) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Continue from a doubly nested finally clause in a loop.
+  //
+
+  printf("    test36...");
+  Counter = 0;
+  for (Index1 = 0; Index1 < 10; Index1 += 1) {
+    try {
+      try {
+        if ((Index1 & 0x1) == 0) {
+          Counter += 1;
+        }
+      }
+      finally { Counter += 2; }
+
+      Counter += 4;
+    }
+    finally {
+      Counter += 5;
+      continue;
+    }
+
+    Counter += 6;
+  }
+
+  if (Counter != 115) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+#endif
+
+  //
+  // Break from a try body with an exception clause in a loop.
+  //
+
+  printf("    test37...");
+  Counter = 0;
+  for (Index1 = 0; Index1 < 10; Index1 += 1) {
+    try {
+      if ((Index1 & 0x1) == 1) {
+        break;
+
+      } else {
+        Counter += 1;
+      }
+    }
+    except(EXCEPTION_EXECUTE_HANDLER) { Counter += 40; }
+
+    Counter += 2;
+  }
+
+  if (Counter != 3) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+#if !defined(WIN_CE) // gotos from try/finally not allowed on WinCE
+  //
+  // Break from a try body with an finally clause in a loop.
+  //
+
+  printf("    test38...");
+  Counter = 0;
+  for (Index1 = 0; Index1 < 10; Index1 += 1) {
+    try {
+      if ((Index1 & 0x1) == 1) {
+        break;
+
+      } else {
+        Counter += 1;
+      }
+    }
+    finally { Counter += 2; }
+
+    Counter += 3;
+  }
+
+  if (Counter != 8) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+#endif
+
+  //
+  // Break from doubly nested try body with an exception clause in a
+  // loop.
+  //
+
+  printf("    test39...");
+  Counter = 0;
+  for (Index1 = 0; Index1 < 10; Index1 += 1) {
+    try {
+      try {
+        if ((Index1 & 0x1) == 1) {
+          break;
+
+        } else {
+          Counter += 1;
+        }
+      }
+      except(EXCEPTION_EXECUTE_HANDLER) { Counter += 10; }
+
+      Counter += 2;
+    }
+    except(EXCEPTION_EXECUTE_HANDLER) { Counter += 20; }
+
+    Counter += 3;
+  }
+
+  if (Counter != 6) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+#if !defined(WIN_CE) // gotos from try/finally not allowed on WinCE
+  //
+  // Break from doubly nested try body with an finally clause in a loop.
+  //
+
+  printf("    test40...");
+  Counter = 0;
+  for (Index1 = 0; Index1 < 10; Index1 += 1) {
+    try {
+      try {
+        if ((Index1 & 0x1) == 1) {
+          break;
+
+        } else {
+          Counter += 1;
+        }
+      }
+      finally { Counter += 2; }
+
+      Counter += 3;
+    }
+    finally { Counter += 4; }
+
+    Counter += 5;
+  }
+
+  if (Counter != 21) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Break from a finally clause in a loop.
+  //
+
+  printf("    test41...");
+  Counter = 0;
+  for (Index1 = 0; Index1 < 10; Index1 += 1) {
+    try {
+      if ((Index1 & 0x1) == 1) {
+        Counter += 1;
+      }
+    }
+    finally {
+      Counter += 2;
+      break;
+    }
+
+    Counter += 4;
+  }
+
+  if (Counter != 2) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Break from a doubly nested finally clause in a loop.
+  //
+
+  printf("    test42...");
+  Counter = 0;
+  for (Index1 = 0; Index1 < 10; Index1 += 1) {
+    try {
+      try {
+        if ((Index1 & 0x1) == 1) {
+          Counter += 1;
+        }
+      }
+      finally {
+        Counter += 2;
+        break;
+      }
+
+      Counter += 4;
+    }
+    finally { Counter += 5; }
+
+    Counter += 6;
+  }
+
+  if (Counter != 7) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Break from a doubly nested finally clause in a loop.
+  //
+
+  printf("    test43...");
+  Counter = 0;
+  for (Index1 = 0; Index1 < 10; Index1 += 1) {
+    try {
+      try {
+        if ((Index1 & 0x1) == 1) {
+          Counter += 1;
+        }
+      }
+      finally { Counter += 2; }
+
+      Counter += 4;
+    }
+    finally {
+      Counter += 5;
+      break;
+    }
+
+    Counter += 6;
+  }
+
+  if (Counter != 11) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+#endif
+
+  //
+  // Break from a try body with an exception clause in a switch.
+  //
+
+  printf("    test44...");
+  Counter = 0;
+  Index1 = 1;
+  switch (Index2) {
+  case BLUE:
+    Counter += 100;
+    break;
+
+  case RED:
+    try {
+      if ((Index1 & 0x1) == 1) {
+        break;
+
+      } else {
+        Counter += 1;
+      }
+    }
+    except(EXCEPTION_EXECUTE_HANDLER) { Counter += 40; }
+
+    Counter += 2;
+    break;
+  }
+
+  if (Counter != 0) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+#if !defined(WIN_CE) // gotos from try/finally not allowed on WinCE
+  //
+  // Break from a try body with an finally clause in a switch.
+  //
+
+  printf("    test45...");
+  Counter = 0;
+  Index1 = 1;
+  switch (Index2) {
+  case BLUE:
+    Counter += 100;
+    break;
+
+  case RED:
+    try {
+      if ((Index1 & 0x1) == 1) {
+        break;
+
+      } else {
+        Counter += 1;
+      }
+    }
+    finally { Counter += 2; }
+
+    Counter += 3;
+  }
+
+  if (Counter != 2) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+#endif
+
+  //
+  // Break from doubly nested try body with an exception clause in a
+  // switch.
+  //
+
+  printf("    test46...");
+  Counter = 0;
+  Index1 = 1;
+  switch (Index2) {
+  case BLUE:
+    Counter += 100;
+    break;
+
+  case RED:
+    try {
+      try {
+        if ((Index1 & 0x1) == 1) {
+          break;
+
+        } else {
+          Counter += 1;
+        }
+      }
+      except(EXCEPTION_EXECUTE_HANDLER) { Counter += 10; }
+
+      Counter += 2;
+    }
+    except(EXCEPTION_EXECUTE_HANDLER) { Counter += 20; }
+
+    Counter += 3;
+  }
+
+  if (Counter != 0) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+#if !defined(WIN_CE) // gotos from try/finally not allowed on WinCE
+  //
+  // Break from doubly nested try body with an finally clause in a switch.
+  //
+
+  printf("    test47...");
+  Counter = 0;
+  Index1 = 1;
+  switch (Index2) {
+  case BLUE:
+    Counter += 100;
+    break;
+
+  case RED:
+    try {
+      try {
+        if ((Index1 & 0x1) == 1) {
+          break;
+
+        } else {
+          Counter += 1;
+        }
+      }
+      finally { Counter += 2; }
+
+      Counter += 3;
+    }
+    finally { Counter += 4; }
+
+    Counter += 5;
+  }
+
+  if (Counter != 6) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Break from a finally clause in a switch.
+  //
+
+  printf("    test48...");
+  Counter = 0;
+  Index1 = 1;
+  switch (Index2) {
+  case BLUE:
+    Counter += 100;
+    break;
+
+  case RED:
+    try {
+      if ((Index1 & 0x1) == 1) {
+        Counter += 1;
+      }
+    }
+    finally {
+      Counter += 2;
+      break;
+    }
+
+    Counter += 4;
+  }
+
+  if (Counter != 3) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Break from a doubly nested finally clause in a switch.
+  //
+
+  printf("    test49...");
+  Counter = 0;
+  Index1 = 1;
+  switch (Index2) {
+  case BLUE:
+    Counter += 100;
+    break;
+
+  case RED:
+    try {
+      try {
+        if ((Index1 & 0x1) == 1) {
+          Counter += 1;
+        }
+      }
+      finally {
+        Counter += 2;
+        break;
+      }
+
+      Counter += 4;
+    }
+    finally { Counter += 5; }
+
+    Counter += 6;
+  }
+
+  if (Counter != 8) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Break from a doubly nested finally clause in a switch.
+  //
+
+  printf("    test50...");
+  Counter = 0;
+  Index1 = 1;
+  switch (Index2) {
+  case BLUE:
+    Counter += 100;
+    break;
+
+  case RED:
+    try {
+      try {
+        if ((Index1 & 0x1) == 1) {
+          Counter += 1;
+        }
+      }
+      finally { Counter += 2; }
+
+      Counter += 4;
+    }
+    finally {
+      Counter += 5;
+      break;
+    }
+
+    Counter += 6;
+  }
+
+  if (Counter != 12) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+#endif
+
+  //
+  // Leave from an if in a simple try/finally.
+  //
+
+  printf("    test51...");
+  Counter = 0;
+  try {
+    if (Echo(Counter) == Counter) {
+      Counter += 3;
+      leave;
+
+    } else {
+      Counter += 100;
+    }
+  }
+  finally {
+    if (abnormal_termination() == FALSE) {
+      Counter += 5;
+    }
+  }
+
+  if (Counter != 8) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Leave from a loop in a simple try/finally.
+  //
+
+  printf("    test52...");
+  Counter = 0;
+  try {
+    for (Index1 = 0; Index1 < 10; Index1 += 1) {
+      if (Echo(Index1) == Index1) {
+        Counter += 3;
+        leave;
+      }
+
+      Counter += 100;
+    }
+  }
+  finally {
+    if (abnormal_termination() == FALSE) {
+      Counter += 5;
+    }
+  }
+
+  if (Counter != 8) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Leave from a switch in a simple try/finally.
+  //
+
+  printf("    test53...");
+  Counter = 0;
+  try {
+    switch (Index2) {
+    case BLUE:
+      break;
+
+    case RED:
+      Counter += 3;
+      leave;
+    }
+
+    Counter += 100;
+  }
+  finally {
+    if (abnormal_termination() == FALSE) {
+      Counter += 5;
+    }
+  }
+
+  if (Counter != 8) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Leave from an if in doubly nested try/finally followed by a leave
+  // from an if in the outer try/finally.
+  //
+
+  printf("    test54...");
+  Counter = 0;
+  try {
+    try {
+      if (Echo(Counter) == Counter) {
+        Counter += 3;
+        leave;
+
+      } else {
+        Counter += 100;
+      }
+    }
+    finally {
+      if (abnormal_termination() == FALSE) {
+        Counter += 5;
+      }
+    }
+
+    if (Echo(Counter) == Counter) {
+      Counter += 3;
+      leave;
+
+    } else {
+      Counter += 100;
+    }
+  }
+  finally {
+    if (abnormal_termination() == FALSE) {
+      Counter += 5;
+    }
+  }
+
+  if (Counter != 16) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+#if !defined(WIN_CE) // leave from finally not allowed on WinCE
+  //
+  // Leave from an if in doubly nested try/finally followed by a leave
+  // from the finally of the outer try/finally.
+  //
+
+  printf("    test55...");
+  Counter = 0;
+  try {
+    try {
+      if (Echo(Counter) == Counter) {
+        Counter += 3;
+        leave;
+
+      } else {
+        Counter += 100;
+      }
+    }
+    finally {
+      if (abnormal_termination() == FALSE) {
+        Counter += 5;
+        leave;
+      }
+    }
+
+    Counter += 100;
+  }
+  finally {
+    if (abnormal_termination() == FALSE) {
+      Counter += 5;
+    }
+  }
+
+  if (Counter != 13) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+#endif
+
+  //
+  // Try/finally within the except clause of a try/except that is always
+  // executed.
+  //
+
+  printf("    test56...");
+  Counter = 0;
+  try {
+    Counter += 1;
+    RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
+  }
+  except(Counter) {
+    try {
+      Counter += 3;
+    }
+    finally {
+      if (abnormal_termination() == FALSE) {
+        Counter += 5;
+      }
+    }
+  }
+
+  if (Counter != 9) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Try/finally within the finally clause of a try/finally.
+  //
+
+  printf("    test57...");
+  Counter = 0;
+  try {
+    Counter += 1;
+  }
+  finally {
+    if (abnormal_termination() == FALSE) {
+      try {
+        Counter += 3;
+      }
+      finally {
+        if (abnormal_termination() == FALSE) {
+          Counter += 5;
+        }
+      }
+    }
+  }
+
+  if (Counter != 9) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Try/except within the finally clause of a try/finally.
+  //
+
+  printf("    test58...");
+#if !defined(NEST_IN_FINALLY)
+  printf("skipped\n");
+#else
+  Counter = 0;
+  try {
+    Counter -= 1;
+  }
+  finally {
+    try {
+      Counter += 2;
+      RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
+    }
+    except(Counter) {
+      try {
+        Counter += 3;
+      }
+      finally {
+        if (abnormal_termination() == FALSE) {
+          Counter += 5;
+        }
+      }
+    }
+  }
+
+  if (Counter != 9) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+#endif /* def(NEST_IN_FINALLY) */
+
+  //
+  // Try/except within the except clause of a try/except that is always
+  // executed.
+  //
+
+  printf("    test59...");
+  Counter = 0;
+  try {
+    Counter += 1;
+    RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
+  }
+  except(Counter) {
+    try {
+      Counter += 3;
+      RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
+    }
+    except(Counter - 3) { Counter += 5; }
+  }
+
+  if (Counter != 9) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Try with a Try which exits the scope with a goto
+  //
+
+  printf("    test60...");
+  Counter = 0;
+  try {
+    try {
+      goto outside;
+    }
+    except(1) { Counter += 1; }
+
+  outside:
+    RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
+  }
+  except(1) { Counter += 3; }
+
+  if (Counter != 3) {
+    printf("failed, count = %d\n", Counter);
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Try/except which gets an exception from a subfunction within
+  // a try/finally which has a try/except in the finally clause
+  //
+
+  printf("    test61...");
+#if !defined(NEST_IN_FINALLY)
+  printf("skipped\n");
+#else
+  Counter = 0;
+  try {
+    Test61Part2(&Counter);
+  }
+  except(EXCEPTION_EXECUTE_HANDLER) { Counter += 11; }
+
+  if (Counter != 24) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+#endif /* def(NEST_IN_FINALLY) */
+
+  //
+  // Check for precision of exception on floating point
+  //
+
+  printf("    test62...");
+
+#if defined(i386) || defined(_M_IA64) || defined(_M_ALPHA) || defined(_M_AMD64)
+
+/* enable floating point overflow */
+#if defined(i386)
+  _control87(_control87(0, 0) & ~EM_OVERFLOW, _MCW_EM);
+#else
+  //
+  // use portable version of _control87
+  //
+  _controlfp(_controlfp(0, 0) & ~EM_OVERFLOW, _MCW_EM);
+#endif
+
+  Counter = 0;
+  try {
+    doubleresult = SquareDouble(1.7e300);
+
+    try {
+      doubleresult = SquareDouble(1.0);
+    }
+    except(1) { Counter += 3; }
+  }
+  except(1) { Counter += 1; }
+
+  if (Counter != 1) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+/* clear up pending unmasked exceptions and restore FP control registers */
+#if defined(i386)
+  _clear87();
+  _control87(_control87(0, 0) | EM_OVERFLOW, 0xfffff);
+#else
+  _clearfp();
+  _controlfp(_controlfp(0, 0) | EM_OVERFLOW, 0xfffff);
+#endif
+
+#else
+  printf("skipped\n");
+#endif
+
+  //
+  // A try/finally inside a try/except where an exception is raised in the
+  // try/finally.
+  //
+
+  printf("    test63...");
+  Counter = 0;
+  try {
+    try {
+      Counter += 1;
+    }
+    finally {
+      Counter += 3;
+      RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
+    }
+  }
+  except(1) { Counter += 6; }
+
+  if (Counter != 10) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // A try/finally inside a try/except where an exception is raised in the
+  // in the try/except and the try/finally.
+  //
+
+  printf("    test64...");
+  Counter = 0;
+  try {
+    try {
+      Counter += 1;
+      RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
+    }
+    finally {
+      Counter += 3;
+      RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
+    }
+  }
+  except(1) { Counter += 6; }
+
+  if (Counter != 10) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // A try/finally inside a try/except where an exception is raised in the
+  // try/finally.
+  //
+
+  printf("    test65...");
+  Counter = 0;
+  try {
+    try {
+      Counter += 1;
+    }
+    finally {
+      Counter += 3;
+      *BlackHole += *BadAddress;
+      Counter += 13;
+    }
+  }
+  except(1) { Counter += 6; }
+
+  if (Counter != 10) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // A try/finally inside a try/except where an exception is raised in the
+  // in the try/except and the try/finally.
+  //
+
+  printf("    test66...");
+  Counter = 0;
+  try {
+    try {
+      Counter += 1;
+      *BlackHole += *BadAddress;
+      Counter += 13;
+    }
+    finally {
+      Counter += 3;
+      *BlackHole += *BadAddress;
+      Counter += 13;
+    }
+  }
+  except(1) { Counter += 6; }
+
+  if (Counter != 10) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // A try/finally inside a try/finally inside a try/except where an
+  // exception is raised in the in the try/except and in try/finally.
+  //
+
+  printf("    test67...");
+  try {
+    try {
+      *BlackHole += *BadAddress;
+    }
+    finally {
+      try {
+        Counter = 0;
+      }
+      finally {
+        if (Counter != 0) {
+          Counter += 1;
+        }
+      }
+
+      Counter += 1;
+      *BlackHole += *BadAddress;
+    }
+  }
+  except(1) { Counter += 1; }
+
+  if (Counter != 2) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // A try/finally inside a try/finally inside a try/except where an
+  // exception is raised in the in the try/except and in try/finally.
+  //
+
+  printf("    test68...");
+  try {
+    try {
+      RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
+    }
+    finally {
+      try {
+        Counter = 0;
+      }
+      finally {
+        if (Counter != 0) {
+          Counter += 1;
+        }
+      }
+
+      Counter += 1;
+      RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
+    }
+  }
+  except(1) { Counter += 1; }
+
+  if (Counter != 2) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+//
+// Patch guard test 69.
+//
+
+#if defined(_AMD64_) || defined(_X86_)
+
+  printf("    test69...");
+  Counter = 0;
+  try {
+    PgTest69(&Counter, BadAddress);
+  }
+  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }
+
+  if (Counter != 2) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  printf("    test70...");
+  Counter = 0;
+  try {
+    PgTest70(&Counter, BadAddress);
+  }
+  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }
+
+  if (Counter != 2) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  printf("    test71...");
+  Counter = 0;
+  try {
+    PgTest71(&Counter, BadAddress);
+  }
+  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }
+
+  if (Counter != 9) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  printf("    test72...");
+  Counter = 0;
+  try {
+    PgTest72(&Counter, BadAddress);
+  }
+  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }
+
+  if (Counter != 12) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  printf("    test73...");
+  Counter = 0;
+  try {
+    PgTest73(&Counter, BadAddress);
+  }
+  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }
+
+  if (Counter != 15) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  printf("    test74...");
+  Counter = 0;
+  try {
+    PgTest74(&Counter, BadAddress);
+  }
+  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }
+
+  if (Counter != 18) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  printf("    test75...");
+  Counter = 0;
+  try {
+    PgTest75(&Counter, BadAddress);
+  }
+  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }
+
+  if (Counter != 35) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  printf("    test76...");
+  Counter = 0;
+  try {
+    PgTest76(&Counter, BadAddress);
+  }
+  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }
+
+  if (Counter != 40) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  printf("    test77...");
+  Counter = 0;
+  try {
+    PgTest77(&Counter, BadAddress);
+  }
+  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }
+
+  if (Counter != 45) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  printf("    test78...");
+  Counter = 0;
+  try {
+    PgTest78(&Counter, BadAddress);
+  }
+  except(EXCEPTION_EXECUTE_HANDLER) { printf("unexpected exception..."); }
+
+  if (Counter != 50) {
+    printf("failed, count = %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+#else
+  printf("    test69...filter entered...succeeded\n");
+  printf("    test70...filter entered...succeeded\n");
+  printf("    test71...filter entered...succeeded\n");
+  printf("    test72...filter entered...succeeded\n");
+  printf("    test73...filter entered...succeeded\n");
+  printf("    test74...filter entered...succeeded\n");
+  printf("    test75...filter entered...succeeded\n");
+  printf("    test76...filter entered...succeeded\n");
+  printf("    test77...filter entered...succeeded\n");
+  printf("    test78...filter entered...succeeded\n");
+#endif
+
+  if (LOBYTE(LOWORD(GetVersion())) < 6) {
+    printf("    test79...");
+    printf("filter 1...filter 2...finally 1...filter 1...filter 2...finally "
+           "2...passed\n");
+  } else {
+
+    printf("    test79...");
+    Counter = 0;
+    try {
+      Test79(&Counter, BadAddress);
+    }
+    except(printf("filter 2..."), EXCEPTION_EXECUTE_HANDLER) { Counter += 1; }
+
+    if (Counter == 3) {
+      printf("passed\n");
+
+    } else {
+      printf("failed  %d \n", Counter);
+    }
+  }
+
+  printf("    test80...");
+  if (Test80() != 0) {
+    printf("failed\n");
+
+  } else {
+    printf("passed\n");
+  }
+
+  printf("    test81...");
+  Counter = 0;
+  Test81(&Counter);
+  if (Counter != 1) {
+    printf("failed  %d \n", Counter);
+
+  } else {
+    printf("passed\n");
+  }
+
+  printf("    test82...");
+  Counter = 1;
+  Test82(&Counter);
+  if (Counter != 0) {
+    printf("failed\n");
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  printf("    test83...");
+  if (Test83() != 0) {
+    printf("failed\n");
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  printf("    test84...");
+  Counter = 0;
+  Test84(&Counter);
+  if (Counter != 2) {
+    printf("failed\n");
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  printf("    test85...");
+  Counter = 0;
+  Test85(&Counter);
+  if (Counter != 7) {
+    printf("failed\n");
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  printf("    test86...");
+  Counter = 0;
+  Test86(&Counter);
+  if (Counter != 4) {
+    printf("failed %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  printf("    test87...");
+  Counter = 0;
+  Test87(&Counter);
+  if (Counter != 104) {
+    printf("failed %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  printf("    test88...");
+  Counter = 0;
+  Test88(&Counter);
+  if (Counter != 6) {
+    printf("failed %d\n", Counter);
+
+  } else {
+    printf("succeeded\n");
+  }
+
+  //
+  // Announce end of exception test.
+  //
+
+  printf("End of exception test\n");
+  return;
+}
+
+#pragma optimize("a", off)
+VOID addtwo(long First, long Second, long *Place)
+
+{
+
+  RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
+  *Place = First + Second;
+  return;
+}
+#pragma optimize("", on)
+
+VOID bar1(IN NTSTATUS Status, IN PLONG Counter) {
+
+  try {
+    foo1(Status);
+  }
+  finally {
+    if (abnormal_termination() != FALSE) {
+      *Counter = 99;
+
+    } else {
+      *Counter = 100;
+    }
+  }
+
+  return;
+}
+
+VOID bar2(IN PLONG BlackHole, IN PLONG BadAddress, IN PLONG Counter) {
+
+  try {
+    foo2(BlackHole, BadAddress);
+  }
+  finally {
+    if (abnormal_termination() != FALSE) {
+      *Counter = 99;
+
+    } else {
+      *Counter = 100;
+    }
+  }
+
+  return;
+}
+
+VOID dojump(IN jmp_buf JumpBuffer, IN PLONG Counter)
+
+{
+
+  try {
+    try {
+      *Counter += 1;
+      RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
+    }
+    finally { *Counter += 1; }
+  }
+  finally {
+    *Counter += 1;
+    longjmp(JumpBuffer, 1);
+  }
+}
+
+#if !defined(WIN_CE) // return through finally not allowed on WinCE
+VOID eret(IN NTSTATUS Status, IN PLONG Counter)
+
+{
+
+  try {
+    try {
+      foo1(Status);
+    }
+    except((GetExceptionCode() == Status) ? EXCEPTION_EXECUTE_HANDLER
+                                          : EXCEPTION_CONTINUE_SEARCH) {
+      *Counter += 1;
+      return;
+    }
+  }
+  finally { *Counter += 1; }
+
+  return;
+}
+#endif
+
+VOID except1(IN PLONG Counter)
+
+{
+
+  try {
+    *Counter += 5;
+    RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
+  }
+  except(except3(GetExceptionInformation(), Counter)) { *Counter += 7; }
+
+  *Counter += 9;
+  return;
+}
+
+ULONG
+except2(IN PEXCEPTION_POINTERS ExceptionPointers, IN PLONG Counter)
+
+{
+
+  PEXCEPTION_RECORD ExceptionRecord;
+
+  ExceptionRecord = ExceptionPointers->ExceptionRecord;
+  if ((ExceptionRecord->ExceptionCode == STATUS_UNSUCCESSFUL) &&
+      ((ExceptionRecord->ExceptionFlags & EXCEPTION_NESTED_CALL) == 0)) {
+    *Counter += 11;
+    return EXCEPTION_EXECUTE_HANDLER;
+
+  } else {
+    *Counter += 13;
+    return EXCEPTION_CONTINUE_SEARCH;
+  }
+}
+
+ULONG
+except3(IN PEXCEPTION_POINTERS ExceptionPointers, IN PLONG Counter)
+
+{
+
+  PEXCEPTION_RECORD ExceptionRecord;
+
+  ExceptionRecord = ExceptionPointers->ExceptionRecord;
+  if ((ExceptionRecord->ExceptionCode == STATUS_INTEGER_OVERFLOW) &&
+      ((ExceptionRecord->ExceptionFlags & EXCEPTION_NESTED_CALL) == 0)) {
+    *Counter += 17;
+    RtlRaiseStatus(STATUS_UNSUCCESSFUL);
+
+  } else if ((ExceptionRecord->ExceptionCode == STATUS_UNSUCCESSFUL) &&
+             ((ExceptionRecord->ExceptionFlags & EXCEPTION_NESTED_CALL) != 0)) {
+    *Counter += 19;
+    return EXCEPTION_CONTINUE_SEARCH;
+  }
+
+  *Counter += 23;
+  return EXCEPTION_EXECUTE_HANDLER;
+}
+
+VOID foo1(IN NTSTATUS Status)
+
+{
+
+  //
+  // Raise exception.
+  //
+
+  RtlRaiseStatus(Status);
+  return;
+}
+
+VOID foo2(IN PLONG BlackHole, IN PLONG BadAddress)
+
+{
+
+  //
+  // Raise exception.
+  //
+
+  *BlackHole += *BadAddress;
+  return;
+}
+
+#if !defined(WIN_CE) // return from finally not allowed on WinCE
+VOID fret(IN PLONG Counter)
+
+{
+
+  try {
+    try {
+      *Counter += 1;
+    }
+    finally {
+      *Counter += 1;
+      return;
+    }
+  }
+  finally { *Counter += 1; }
+
+  return;
+}
+#endif
+
+LONG Echo(IN LONG Value)
+
+{
+  return Value;
+}
+
+#if defined(NEST_IN_FINALLY)
+VOID Test61Part2(IN OUT PULONG Counter) {
+  try {
+    *Counter -= 1;
+    RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
+  }
+  finally {
+    try {
+      *Counter += 2;
+      RtlRaiseStatus(STATUS_INTEGER_OVERFLOW);
     }
+    except(EXCEPTION_EXECUTE_HANDLER) { *Counter += 5; }
+    *Counter += 7;
+  }
+}
+#endif /* def(NEST_IN_FINALLY) */
+
+double SquareDouble(IN double op) {
+  return exp(2.0 * log(op));
 }

test/samples/sample.cameligo.txt

@@ -0,0 +1,17 @@
+type storage = int
+type parameter =
+  Increment of int
+| Decrement of int
+| Reset
+type return = operation list * storage
+// Two entrypoints
+let add (store, delta : storage * int) : storage = store + delta
+let sub (store, delta : storage * int) : storage = store - delta
+(* Main access point that dispatches to the entrypoints according to
+   the smart contract parameter. *)
+let main (action, store : parameter * storage) : return =
+ ([] : operation list),    // No operations
+ (match action with
+   Increment (n) -> add (store, n)
+ | Decrement (n) -> sub (store, n)
+ | Reset         -> 0)

test/samples/sample.clojure.txt

@@ -0,0 +1,54 @@
+(ns game-of-life
+  "Conway's Game of Life, based on the work of
+  Christophe Grand (http://clj-me.cgrand.net/2011/08/19/conways-game-of-life)
+  and Laurent Petit (https://gist.github.com/1200343).")
+
+;;; Core game of life's algorithm functions
+
+(defn neighbors
+  "Given a cell's coordinates `[x y]`, returns the coordinates of its
+  neighbors."
+  [[x y]]
+  (for [dx [-1 0 1]
+        dy (if (zero? dx)
+             [-1 1]
+             [-1 0 1])]
+    [(+ dx x) (+ dy y)]))
+
+(defn step
+  "Given a set of living `cells`, computes the new set of living cells."
+  [cells]
+  (set (for [[cell n] (frequencies (mapcat neighbors cells))
+             :when (or (= n 3)
+                       (and (= n 2)
+                            (cells cell)))]
+         cell)))
+
+;;; Utility methods for displaying game on a text terminal
+
+(defn print-grid
+  "Prints a `grid` of `w` columns and `h` rows, on *out*, representing a
+  step in the game."
+  [grid w h]
+  (doseq [x (range (inc w))
+          y (range (inc h))]
+    (when (= y 0) (println))
+    (print (if (grid [x y])
+             "[X]"
+             " . "))))
+
+(defn print-grids
+  "Prints a sequence of `grids` of `w` columns and `h` rows on *out*,
+  representing several steps."
+  [grids w h]
+  (doseq [grid grids]
+    (print-grid grid w h)
+    (println)))
+
+;;; Launches an example grid
+
+(def grid
+  "`grid` represents the initial set of living cells"
+  #{[2 1] [2 2] [2 3]})
+
+(print-grids (take 3 (iterate step grid)) 5 5)

test/samples/sample.csp.txt

@@ -0,0 +1 @@
+Content-Security-Policy: default-src 'self'; img-src *; media-src media1.com media2.com; script-src userscripts.example.com

test/samples/sample.dart.txt

@@ -0,0 +1,37 @@
+import 'dart:async';
+import 'dart:math' show Random;
+main() async {
+  print('Compute π using the Monte Carlo method.');
+  await for (var estimate in computePi().take(100)) {
+    print('π ≅ $estimate');
+  }
+}
+/// Generates a stream of increasingly accurate estimates of π.
+Stream<double> computePi({int batch: 100000}) async* {
+  var total = 0;
+  var count = 0;
+  while (true) {
+    var points = generateRandom().take(batch);
+    var inside = points.where((p) => p.isInsideUnitCircle);
+    total += batch;
+    count += inside.length;
+    var ratio = count / total;
+    // Area of a circle is A = π⋅r², therefore π = A/r².
+    // So, when given random points with x ∈ <0,1>,
+    // y ∈ <0,1>, the ratio of those inside a unit circle
+    // should approach π / 4. Therefore, the value of π
+    // should be:
+    yield ratio * 4;
+  }
+}
+Iterable<Point> generateRandom([int seed]) sync* {
+  final random = Random(seed);
+  while (true) {
+    yield Point(random.nextDouble(), random.nextDouble());
+  }
+}
+class Point {
+  final double x, y;
+  const Point(this.x, this.y);
+  bool get isInsideUnitCircle => x * x + y * y <= 1;
+}

test/samples/sample.julia.txt

@@ -0,0 +1,23 @@
+# good style
+function fixedpointmap(f; iv, tolerance=1E-7, maxiter=1000)
+    # setup the algorithm
+    x_old = iv
+    normdiff = Inf
+    iter = 1
+    while normdiff > tolerance && iter <= maxiter
+        x_new = f(x_old) # use the passed in map
+        normdiff = norm(x_new - x_old)
+        x_old = x_new
+        iter = iter + 1
+    end
+    return (value = x_old, normdiff=normdiff, iter=iter) # A named tuple
+end
+
+# define a map and parameters
+p = 1.0
+β = 0.9
+f(v) = p + β * v # note that p and β are used in the function!
+
+sol = fixedpointmap(f, iv=0.8, tolerance=1.0E-8) # don't need to pass
+println("Fixed point = $(sol.value), and |f(x) - x| = $(sol.normdiff) in $(sol.iter)"*
+        " iterations")

test/samples/sample.kotlin.txt

@@ -0,0 +1,28 @@
+const val POINTS_X_PASS: Int = 15
+val EZPassAccounts: MutableMap<Int, Int> = mutableMapOf(1 to 100, 2 to 100, 3 to 100)
+val EZPassReport: Map<Int, Int> = EZPassAccounts
+
+// update points credit
+fun updatePointsCredit(accountId: Int) {
+    if (EZPassAccounts.containsKey(accountId)) {
+        println("Updating $accountId...")
+        EZPassAccounts[accountId] = EZPassAccounts.getValue(accountId) + POINTS_X_PASS
+    } else {
+        println("Error: Trying to update a non-existing account (id: $accountId)")
+    }
+}
+
+fun accountsReport() {
+    println("EZ-Pass report:")
+    EZPassReport.forEach{
+        k, v -> println("ID $k: credit $v")
+    }
+}
+
+fun main() {
+    accountsReport()
+    updatePointsCredit(1)
+    updatePointsCredit(1)
+    updatePointsCredit(5)
+    accountsReport()
+}

test/samples/sample.lex.txt

@@ -0,0 +1,21 @@
+LEX Paid Escrow.
+LEXON: 0.2.20
+COMMENT: 3.f - an escrow that is controlled by a third party for a fee.
+
+“Payer” is a person.
+“Payee” is a person.
+“Arbiter” is a person.
+“Fee” is an amount.
+
+The Payer pays an Amount into escrow,
+appoints the Payee,
+appoints the Arbiter,
+and also fixes the Fee.
+
+CLAUSE: Pay Out.
+The Arbiter may pay from escrow the Fee to themselves,
+and afterwards pay the remainder of the escrow to the Payee.
+
+CLAUSE: Pay Back.
+The Arbiter may pay from escrow the Fee to themselves,
+and afterwards return the remainder of the escrow to the Payer.

test/samples/sample.mips.txt

@@ -0,0 +1,13 @@
+# A[i] = A[i/2] + 1;
+    lw     $t0, 0($gp)       # fetch i
+    srl    $t1, $t0, 1       # i/2
+    sll    $t1, $t1, 2       # turn i/2 into a byte offset (*4)
+    add    $t1, $gp, $t1     # &A[i/2] - 28
+    lw     $t1, 28($t1)      # fetch A[i/2]
+    addi   $t1, $t1, 1       # A[i/2] + 1
+    sll    $t2, $t0, 2       # turn i into a byte offset
+    add    $t2, $t2, $gp     # &A[i] - 28
+    sw     $t1, 28($t2)      # A[i] = ...
+# A[i+1] = -1;
+    addi   $t1, $zero, -1    # -1
+    sw     $t1, 32($t2)      # A[i+1] = -1

test/samples/sample.mysql.txt

@@ -0,0 +1,8 @@
+CREATE TABLE shop (
+    article INT(4) UNSIGNED ZEROFILL DEFAULT '0000' NOT NULL,
+    dealer  CHAR(20)                 DEFAULT ''     NOT NULL,
+    price   DOUBLE(16,2)             DEFAULT '0.00' NOT NULL,
+    PRIMARY KEY(article, dealer));
+INSERT INTO shop VALUES
+    (1,'A',3.45),(1,'B',3.99),(2,'A',10.99),(3,'B',1.45),
+    (3,'C',1.69),(3,'D',1.25),(4,'D',19.95);

test/samples/sample.pascal.txt

@@ -26,4 +26,3 @@ begin
       Writeln(E.ClassName, ': ', E.Message);
   end;
 end.
-

test/samples/sample.pascaligo.txt

@@ -0,0 +1,20 @@
+type storage is int
+type parameter is
+  Increment of int
+| Decrement of int
+| Reset
+type return is list (operation) * storage
+// Two entrypoints
+function add (const store : storage; const delta : int) : storage is
+  store + delta
+function sub (const store : storage; const delta : int) : storage is
+  store - delta
+(* Main access point that dispatches to the entrypoints according to
+   the smart contract parameter. *)
+function main (const action : parameter; const store : storage) : return is
+ ((nil : list (operation)),    // No operations
+  case action of
+    Increment (n) -> add (store, n)
+  | Decrement (n) -> sub (store, n)
+  | Reset         -> 0
+  end)

test/samples/sample.perl.txt

@@ -0,0 +1,18 @@
+#!/usr/bin/perl
+use strict;
+use warnings;
+
+use Path::Tiny;
+
+my $dir = path('foo','bar'); # foo/bar
+
+# Iterate over the content of foo/bar
+my $iter = $dir->iterator;
+while (my $file = $iter->()) {
+
+    # See if it is a directory and skip
+    next if $file->is_dir();
+
+    # Print out the file name and path
+    print "$file\n";
+}

test/samples/sample.pgsql.txt

@@ -0,0 +1,8 @@
+BEGIN
+    SELECT * INTO STRICT myrec FROM emp WHERE empname = myname;
+    EXCEPTION
+        WHEN NO_DATA_FOUND THEN
+            RAISE EXCEPTION 'employee % not found', myname;
+        WHEN TOO_MANY_ROWS THEN
+            RAISE EXCEPTION 'employee % not unique', myname;
+END;

test/samples/sample.powerquery.txt

@@ -0,0 +1,12 @@
+let
+    Source = Excel.CurrentWorkbook(){[Name="Table1"]}[Content],
+    SplitColumnDelimiter = Table.SplitColumn(Source,"Input",Splitter.SplitTextByDelimiter(","),13),
+    Unpivot = Table.Unpivot(SplitColumnDelimiter,{"Input.1", "Input.2", "Input.3", "Input.4",
+    "Input.5", "Input.6",    "Input.7", "Input.8", "Input.9", "Input.10", "Input.11", "Input.12"
+    ,  "Input.13"},"Attribute","Value"),
+    RemovedColumns = Table.RemoveColumns(Unpivot,{"Attribute"}),
+    DuplicatesRemoved = Table.Distinct(RemovedColumns),
+    GroupedRows = Table.Group(DuplicatesRemoved, {"RowID"}, {{"Count of Distinct Values"
+    , each Table.RowCount(_), type number}})
+in
+    GroupedRows

test/samples/sample.redis.txt

@@ -0,0 +1,4 @@
+EXISTS mykey
+APPEND mykey "Hello"
+APPEND mykey " World"
+GET mykey

test/samples/sample.redshift.txt

@@ -0,0 +1,9 @@
+create view tables_vw as
+select distinct(id) table_id
+,trim(datname)   db_name
+,trim(nspname)   schema_name
+,trim(relname)   table_name
+from stv_tbl_perm
+join pg_class on pg_class.oid = stv_tbl_perm.id
+join pg_namespace on pg_namespace.oid = relnamespace
+join pg_database on pg_database.oid = stv_tbl_perm.db_id;

test/samples/sample.restructuredtext.txt

@@ -0,0 +1,26 @@
+=================
+My Project Readme
+=================
+-------------------------
+Clever subtitle goes here
+-------------------------
+
+Introduction
+============
+
+This is an example reStructuredText document that starts at the very top
+with a title and a sub-title. There is one primary header, Introduction.
+There is one example subheading below.
+The document is just plain text so it is easily readable even before
+being converted to HTML, man page, PDF or other formats.
+
+Subheading
+----------
+
+The basic syntax is not that different from Markdown, but it also
+has many more powerful features that Markdown doesn't have. We aren't
+taking advantage of those yet though.
+
+- Bullet points
+- Are intuitive
+- And simple too

test/samples/sample.rust.txt

@@ -0,0 +1,29 @@
+fn main() {
+    let greetings = ["Hello", "Hola", "Bonjour",
+                     "Ciao", "こんにちは", "안녕하세요",
+                     "Cześć", "Olá", "Здравствуйте",
+                     "Chào bạn", "您好", "Hallo",
+                     "Hej", "Ahoj", "سلام"];
+
+    for (num, greeting) in greetings.iter().enumerate() {
+        print!("{} : ", greeting);
+        match num {
+            0 =>  println!("This code is editable and runnable!"),
+            1 =>  println!("¡Este código es editable y ejecutable!"),
+            2 =>  println!("Ce code est modifiable et exécutable !"),
+            3 =>  println!("Questo codice è modificabile ed eseguibile!"),
+            4 =>  println!("このコードは編集して実行出来ます！"),
+            5 =>  println!("여기에서 코드를 수정하고 실행할 수 있습니다!"),
+            6 =>  println!("Ten kod można edytować oraz uruchomić!"),
+            7 =>  println!("Este código é editável e executável!"),
+            8 =>  println!("Этот код можно отредактировать и запустить!"),
+            9 =>  println!("Bạn có thể edit và run code trực tiếp!"),
+            10 => println!("这段代码是可以编辑并且能够运行的！"),
+            11 => println!("Dieser Code kann bearbeitet und ausgeführt werden!"),
+            12 => println!("Den här koden kan redigeras och köras!"),
+            13 => println!("Tento kód můžete upravit a spustit"),
+            14 => println!("این کد قابلیت ویرایش و اجرا دارد!"),
+            _ =>  {},
+        }
+    }
+}

test/samples/sample.sb.txt

@@ -0,0 +1,10 @@
+begin:
+TextWindow.Write("Enter a number: ")
+num = TextWindow.ReadNumber()
+remainder = Math.Remainder(num, 2)
+If (remainder = 0) Then
+ TextWindow.WriteLine("The number is Even")
+Else
+ TextWindow.WriteLine("The number is Odd")
+EndIf
+Goto begin

test/samples/sample.scala.txt

@@ -0,0 +1,53 @@
+package examples
+
+/** Quick sort, imperative style */
+object sort {
+
+  /** Nested methods can use and even update everything
+   *  visible in their scope (including local variables or
+   *  arguments of enclosing methods).
+   */
+  def sort(a: Array[Int]) {
+
+    def swap(i: Int, j: Int) {
+      val t = a(i); a(i) = a(j); a(j) = t
+    }
+
+    def sort1(l: Int, r: Int) {
+      val pivot = a((l + r) / 2)
+      var i = l
+      var j = r
+      while (i <= j) {
+        while (a(i) < pivot) i += 1
+        while (a(j) > pivot) j -= 1
+        if (i <= j) {
+          swap(i, j)
+          i += 1
+          j -= 1
+        }
+      }
+      if (l < j) sort1(l, j)
+      if (j < r) sort1(i, r)
+    }
+
+    if (a.length > 0)
+      sort1(0, a.length - 1)
+  }
+
+  def println(ar: Array[Int]) {
+    def print1 = {
+      def iter(i: Int): String =
+        ar(i) + (if (i < ar.length-1) "," + iter(i+1) else "")
+      if (ar.length == 0) "" else iter(0)
+    }
+    Console.println("[" + print1 + "]")
+  }
+
+  def main(args: Array[String]) {
+    val ar = Array(6, 2, 8, 5, 1)
+    println(ar)
+    sort(ar)
+    println(ar)
+  }
+
+}

test/samples/sample.scheme.txt

@@ -0,0 +1,105 @@
+;;; make-matrix creates a matrix (a vector of vectors).
+(define make-matrix
+  (lambda (rows columns)
+    (do ((m (make-vector rows))
+         (i 0 (+ i 1)))
+        ((= i rows) m)
+        (vector-set! m i (make-vector columns)))))
+
+;;; matrix? checks to see if its argument is a matrix.
+;;; It isn't foolproof, but it's generally good enough.
+(define matrix?
+  (lambda (x)
+    (and (vector? x)
+         (> (vector-length x) 0)
+         (vector? (vector-ref x 0)))))
+
+;; matrix-rows returns the number of rows in a matrix.
+(define matrix-rows
+   (lambda (x)
+      (vector-length x)))
+
+;; matrix-columns returns the number of columns in a matrix.
+(define matrix-columns
+   (lambda (x)
+      (vector-length (vector-ref x 0))))
+
+;;; matrix-ref returns the jth element of the ith row.
+(define matrix-ref
+  (lambda (m i j)
+    (vector-ref (vector-ref m i) j)))
+
+;;; matrix-set! changes the jth element of the ith row.
+(define matrix-set!
+  (lambda (m i j x)
+    (vector-set! (vector-ref m i) j x)))
+
+;;; mul is the generic matrix/scalar multiplication procedure
+(define mul
+  (lambda (x y)
+    ;; mat-sca-mul multiplies a matrix by a scalar.
+    (define mat-sca-mul
+       (lambda (m x)
+          (let* ((nr (matrix-rows m))
+                 (nc (matrix-columns m))
+                 (r  (make-matrix nr nc)))
+             (do ((i 0 (+ i 1)))
+                 ((= i nr) r)
+                 (do ((j 0 (+ j 1)))
+                     ((= j nc))
+                     (matrix-set! r i j
+                        (* x (matrix-ref m i j))))))))
+
+    ;; mat-mat-mul multiplies one matrix by another, after verifying
+    ;; that the first matrix has as many columns as the second
+    ;; matrix has rows.
+    (define mat-mat-mul
+       (lambda (m1 m2)
+          (let* ((nr1 (matrix-rows m1))
+                 (nr2 (matrix-rows m2))
+                 (nc2 (matrix-columns m2))
+                 (r   (make-matrix nr1 nc2)))
+             (if (not (= (matrix-columns m1) nr2))
+                 (match-error m1 m2))
+             (do ((i 0 (+ i 1)))
+                 ((= i nr1) r)
+                 (do ((j 0 (+ j 1)))
+                     ((= j nc2))
+                     (do ((k 0 (+ k 1))
+                          (a 0
+                             (+ a
+                                (* (matrix-ref m1 i k)
+                                   (matrix-ref m2 k j)))))
+                         ((= k nr2)
+                          (matrix-set! r i j a))))))))
+
+   ;; type-error is called to complain when mul receives an invalid
+   ;; type of argument.
+    (define type-error
+       (lambda (what)
+          (error 'mul
+             "~s is not a number or matrix"
+             what)))
+
+    ;; match-error is called to complain when mul receives a pair of
+    ;; incompatible arguments.
+    (define match-error
+       (lambda (what1 what2)
+          (error 'mul
+             "~s and ~s are incompatible operands"
+             what1
+             what2)))
+
+    ;; body of mul; dispatch based on input types
+    (cond
+      ((number? x)
+       (cond
+         ((number? y) (* x y))
+         ((matrix? y) (mat-sca-mul y x))
+         (else (type-error y))))
+      ((matrix? x)
+       (cond
+         ((number? y) (mat-sca-mul x y))
+         ((matrix? y) (mat-mat-mul x y))
+         (else (type-error y))))
+      (else (type-error x)))))

test/samples/sample.shell.txt

@@ -0,0 +1,42 @@
+#!/bin/bash
+# Simple line count example, using bash
+#
+# Bash tutorial: http://linuxconfig.org/Bash_scripting_Tutorial#8-2-read-file-into-bash-array
+# My scripting link: http://www.macs.hw.ac.uk/~hwloidl/docs/index.html#scripting
+#
+# Usage: ./line_count.sh file
+# -----------------------------------------------------------------------------
+
+# Link filedescriptor 10 with stdin
+exec 10<&0
+# stdin replaced with a file supplied as a first argument
+exec < $1
+# remember the name of the input file
+in=$1
+
+# init
+file="current_line.txt"
+let count=0
+
+# this while loop iterates over all lines of the file
+while read LINE
+do
+    # increase line counter
+    ((count++))
+    # write current line to a tmp file with name $file (not needed for counting)
+    echo $LINE > $file
+    # this checks the return code of echo (not needed for writing; just for demo)
+    if [ $? -ne 0 ]
+     then echo "Error in writing to file ${file}; check its permissions!"
+    fi
+done
+
+echo "Number of lines: $count"
+echo "The last line of the file is: `cat ${file}`"
+
+# Note: You can achieve the same by just using the tool wc like this
+echo "Expected number of lines: `wc -l $in`"
+
+# restore stdin from filedescriptor 10
+# and close filedescriptor 10
+exec 0<&10 10<&-

test/samples/sample.st.txt

@@ -0,0 +1,34 @@
+CONFIGURATION DefaultCfg
+    VAR_GLOBAL
+        Start_Stop AT %IX0.0: BOOL; (* This is a comment *)
+    END_VAR
+    TASK NewTask  (INTERVAL := T#20ms);
+    PROGRAM Main WITH NewTask : PLC_PRG;
+END_CONFIGURATION
+
+PROGRAM demo
+    VAR_EXTERNAL
+        Start_Stop: BOOL;
+    END_VAR
+    VAR
+        a : REAL; // Another comment
+        todTest: TIME_OF_DAY := TOD#12:55;
+    END_VAR
+    a := csq(12.5);
+    TON1(IN := TRUE, PT := T#2s);
+    16#FAC0 2#1001_0110
+    IF TON1.Q AND a > REAL#100 THEN
+        Start_Stop := TRUE;
+    END_IF
+END_PROGRAM;
+
+/* Get a square of the circle */
+FUNCTION csq : REAL
+    VAR_INPUT
+        r: REAL;
+    END_VAR
+    VAR CONSTANT
+        c_pi: REAL := 3.14;
+    END_VAR
+    csq := ABS(c_pi * (r * 2));
+END_FUNCTION

test/samples/sample.systemverilog.txt

@@ -0,0 +1,28 @@
+// File : tb_top.sv
+module tb_top ();
+
+	reg clk;
+	reg resetn;
+	reg d;
+	wire q;
+
+	// Instantiate the design
+	d_ff  d_ff0 (	.clk (clk),
+		       		.resetn (resetn),
+		       		.d (d),
+		       		.q (q));
+
+	// Create a clock
+	always #10 clk <= ~clk;
+
+	initial begin
+		resetn <= 0;
+		d <= 0;
+
+		#10 resetn <= 1;
+		#5      d <= 1;
+		#8      d <= 0;
+		#2      d <= 1;
+		#10     d <= 0;
+	end
+endmodule

test/samples/sample.tcl.txt

@@ -0,0 +1,18 @@
+proc find {{basedir .} {filterScript {}}} {
+    set oldwd [pwd]
+    cd $basedir
+    set cwd [pwd]
+    set filenames [glob -nocomplain * .*]
+    set files {}
+    set filt [string length $filterScript]
+    foreach filename $filenames {
+        if {!$filt || [eval $filterScript [list $filename]]} {
+            lappend files [file join $cwd $filename]
+        }
+        if {[file isdirectory $filename]} {
+            set files [concat $files [find $filename $filterScript]]
+        }
+    }
+    cd $oldwd
+    return $files
+}

test/samples/sample.twig.txt

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="UTF-8">
+        <title>{% block title %}Welcome!{% endblock %}</title>
+        {% block stylesheets %}{% endblock %}
+    </head>
+    <body>
+        {% block body %}{% endblock %}
+        {% block javascripts %}{% endblock %}
+    </body>
+</html>

test/samples/sample.verilog.txt

@@ -0,0 +1,35 @@
+`include "first_counter.v"
+module first_counter_tb();
+// Declare inputs as regs and outputs as wires
+reg clock, reset, enable;
+wire [3:0] counter_out;
+
+// Initialize all variables
+initial begin
+  $display ("time\t clk reset enable counter");
+  $monitor ("%g\t %b   %b     %b      %b",
+	  $time, clock, reset, enable, counter_out);
+  clock = 1;       // initial value of clock
+  reset = 0;       // initial value of reset
+  enable = 0;      // initial value of enable
+   #5  reset = 1;    // Assert the reset
+   #10  reset = 0;   // De-assert the reset
+   #10  enable = 1;  // Assert enable
+   #100  enable = 0; // De-assert enable
+   #5  $finish;      // Terminate simulation
+end
+
+// Clock generator
+always begin
+   #5  clock = ~clock; // Toggle clock every 5 ticks
+end
+
+// Connect DUT to test bench
+first_counter U_counter (
+clock,
+reset,
+enable,
+counter_out
+);
+
+endmodule

website/index/samples/sample.aes.txt

@@ -0,0 +1,38 @@
+// Contract simulating developers organization
+contract HackBG =
+
+    record state = { developers: map(address, developer) }
+
+    record developer = { name: string
+                       , age: int
+                       , skillset: map(skill, experience) }
+
+    type skill = string
+    type experience = int
+
+    datatype event =
+          LogDeveloperAdded(indexed address, indexed int, string)
+
+    entrypoint init() : state = { developers = {} }
+
+    stateful entrypoint dev_add(account: address, dev_name: string, dev_age: int) =
+        require(!is_member(account), "ERROR_DEVELOPER_ALREADY_EXISTS")
+        let dev : developer = { name = dev_name
+                              , age = dev_age
+                              , skillset = {} }
+        put(state{ developers[account] = dev })
+        Chain.event(LogDeveloperAdded(account, Chain.timestamp, dev_name))
+
+    stateful entrypoint dev_update(account: address, dev_name: string, dev_age: int) =
+        require(is_member(account), "ERROR_DEVELOPER_DOES_NOT_EXIST")
+        put(state{ developers[account].name = dev_name })
+        put(state{ developers[account].age = dev_age })
+
+    function is_member(account: address) : bool =
+        Map.member(account, state.developers)
+
+    stateful entrypoint dev_skill_modify(account: address, skill: string, experience: int) =
+        put(state{ developers[account].skillset[skill] = experience })
+
+    entrypoint dev_get(account: address) : developer =
+        state.developers[account]

website/index/samples/sample.cameligo.txt

@@ -0,0 +1,17 @@
+type storage = int
+type parameter =
+  Increment of int
+| Decrement of int
+| Reset
+type return = operation list * storage
+// Two entrypoints
+let add (store, delta : storage * int) : storage = store + delta
+let sub (store, delta : storage * int) : storage = store - delta
+(* Main access point that dispatches to the entrypoints according to
+   the smart contract parameter. *)
+let main (action, store : parameter * storage) : return =
+ ([] : operation list),    // No operations
+ (match action with
+   Increment (n) -> add (store, n)
+ | Decrement (n) -> sub (store, n)
+ | Reset         -> 0)

website/index/samples/sample.csharp.txt

@@ -1,23 +1,38 @@
+/*
+* C# Program to Display All the Prime Numbers Between 1 to 100
+*/
+
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 using System.Text;
-using System.Threading.Tasks;
 
 namespace VS
 {
 	class Program
 	{
 		static void Main(string[] args)
-		{
-			ProcessStartInfo si = new ProcessStartInfo();
-			float load= 3.2e02f;
-
-			si.FileName = @"tools\\node.exe";
-			si.Arguments = "tools\\simpleserver.js";
-
-			Process.Start(si);
+    		{
+			bool isPrime = true;
+			Console.WriteLine("Prime Numbers : ");
+			for (int i = 2; i <= 100; i++)
+			{
+				for (int j = 2; j <= 100; j++)
+				{
+					if (i != j && i % j == 0)
+					{
+						isPrime = false;
+						break;
+					}
+				}
+				
+				if (isPrime)
+				{
+					Console.Write("\t" +i);
+				}
+				isPrime = true;
+			}
+			Console.ReadKey();
 		}
 	}
 }

website/index/samples/sample.dart.txt

@@ -0,0 +1,37 @@
+import 'dart:async';
+import 'dart:math' show Random;
+main() async {
+  print('Compute π using the Monte Carlo method.');
+  await for (var estimate in computePi().take(100)) {
+    print('π ≅ $estimate');
+  }
+}
+/// Generates a stream of increasingly accurate estimates of π.
+Stream<double> computePi({int batch: 100000}) async* {
+  var total = 0;
+  var count = 0;
+  while (true) {
+    var points = generateRandom().take(batch);
+    var inside = points.where((p) => p.isInsideUnitCircle);
+    total += batch;
+    count += inside.length;
+    var ratio = count / total;
+    // Area of a circle is A = π⋅r², therefore π = A/r².
+    // So, when given random points with x ∈ <0,1>,
+    // y ∈ <0,1>, the ratio of those inside a unit circle
+    // should approach π / 4. Therefore, the value of π
+    // should be:
+    yield ratio * 4;
+  }
+}
+Iterable<Point> generateRandom([int seed]) sync* {
+  final random = Random(seed);
+  while (true) {
+    yield Point(random.nextDouble(), random.nextDouble());
+  }
+}
+class Point {
+  final double x, y;
+  const Point(this.x, this.y);
+  bool get isInsideUnitCircle => x * x + y * y <= 1;
+}

website/index/samples/sample.graphql.txt

@@ -1,263 +1,263 @@
-# GraphQL Schema Definition Language
-
-"""
-Color value
-"""
-scalar Color
-
-"""
-Node interface
-
-- allows (re)fetch arbitrary entity only by ID
-- allows client side cache normalization
-
-See [Relay Global Object Identification Specification](https://facebook.github.io/relay/graphql/objectidentification.htm)
-"""
-interface Node {
-  """
-  Globally unique identifier,
-  typically `${__typename}:${dbId}`
-  may be encoded in *base64*
-  """
-  id: ID!
-}
-
-"""
-A character in the Star Wars Trilogy
-"""
-interface Character {
-  """
-  The id of the character.
-  """
-  id: ID!
-
-  """
-  The name of the character.
-  """
-  name: String
-
-  """
-  The friends of the character, or an empty list if they have none.
-  """
-  friends: [Character]
-
-  """
-  Which movies they appear in
-  """
-  appearsIn: [Episode]
-
-  """
-  All secrets about their past
-  """
-  secretBackstory: String
-}
-
-"""
-A mechanical creature in the Star Wars universe.
-"""
-type Droid implements Character {
-  """
-  The id of the droid.
-  """
-  id: ID!
-
-  """
-  The name of the droid.
-  """
-  name: String
-
-  """
-  The friends of the droid, or an empty list if they have none.
-  """
-  friends: [Character]
-
-  """
-  Which movies they appear in.
-  """
-  appearsIn: [Episode]
-
-  """
-  Construction date and the name of the designer.
-  """
-  secretBackstory: String
-
-  """
-  The primary function of the droid.
-  """
-  primaryFunction: String
-
-  """
-  Chase color of the droid.
-  """
-  color: Color
-}
-
-# One of the films in the Star Wars Trilogy
-enum Episode {
-  """
-  Released in 1977.
-  """
-  NEWHOPE
-
-  """
-  Released in 1980.
-  """
-  EMPIRE
-
-  """
-  Released in 1983.
-  """
-  JEDI
-}
-
-"""
-A humanoid creature in the Star Wars universe.
-"""
-type Human implements Character {
-  """
-  The id of the human.
-  """
-  id: ID!
-
-  """
-  The name of the human.
-  """
-  name: String
-
-  """
-  The friends of the human, or an empty list if they have none.
-  """
-  friends: [Character]
-
-  """
-  Which movies they appear in.
-  """
-  appearsIn: [Episode]
-
-  """
-  The home planet of the human, or null if unknown.
-  """
-  homePlanet: String
-
-  """
-  Where are they from and how they came to be who they are.
-  """
-  secretBackstory: String
-}
-
-enum LengthUnit {
-  METER
-  FEET
-}
-
-type Starship {
-  id: ID!
-  name: String!
-  length(unit: LengthUnit = METER): Float
-}
-
-union SearchResult = Human | Droid | Starship
-
-input SearchInput {
-  name: String
-  episode: Episode
-}
-
-"""
-Root Query
-"""
-type Query {
-  """
-  Return the hero by episode.
-  """
-  hero(
-    """
-    If omitted, returns the hero of the whole saga. If provided, returns the hero of that particular episode.
-    """
-    episode: Episode
-  ): Character
-
-  """
-  Return the Human by ID.
-  """
-  human(
-    """
-    id of the human
-    """
-    id: ID!
-  ): Human
-
-  """
-  Return the Droid by ID.
-  """
-  droid(
-    """
-    id of the droid
-    """
-    id: ID!
-  ): Droid
-
-  """
-  Search everything by name
-
-  __NOTE__: You should use Relay pagination
-  """
-  search(search: SearchInput!): [SearchResult]
-    @deprecated(reason: "`search` will be replaced.")
-}
-
-"""
-Root Mutation
-"""
-type Mutation {
-  """
-  Save the favorite episode.
-  """
-  favorite(
-    """
-    Favorite episode.
-    """
-    episode: Episode!
-  ): Episode
-}
-
-"""
-Subscriptions — live events
-"""
-type Subscription {
-  """
-  Message
-  """
-  message: String
-}
-
-extend type Query {
-  """
-  Dummy query for highlighting test
-  """
-  dummy(
-    int: Int = 123
-    float: Float = 123.456
-    str: String = "Hello World!"
-    boolDefaultTrue: Boolean = true
-    boolDefaultFalse: Boolean = false
-    id: ID
-    search: SearchInput = null
-  ): Boolean
-}
-
-schema {
-  query: Query
-  mutation: Mutation
-  subscription: Subscription
-}
-
-# GraphQL Query Language
-
-query dummyQuery($int: Int) {
-  dummy(int: $int)
-}
-
-mutation favoriteEpisode($episode: Episode) {
-  favorite(episode: $episode)
-}
+# GraphQL Schema Definition Language
+
+"""
+Color value
+"""
+scalar Color
+
+"""
+Node interface
+
+- allows (re)fetch arbitrary entity only by ID
+- allows client side cache normalization
+
+See [Relay Global Object Identification Specification](https://facebook.github.io/relay/graphql/objectidentification.htm)
+"""
+interface Node {
+  """
+  Globally unique identifier,
+  typically `${__typename}:${dbId}`
+  may be encoded in *base64*
+  """
+  id: ID!
+}
+
+"""
+A character in the Star Wars Trilogy
+"""
+interface Character {
+  """
+  The id of the character.
+  """
+  id: ID!
+
+  """
+  The name of the character.
+  """
+  name: String
+
+  """
+  The friends of the character, or an empty list if they have none.
+  """
+  friends: [Character]
+
+  """
+  Which movies they appear in
+  """
+  appearsIn: [Episode]
+
+  """
+  All secrets about their past
+  """
+  secretBackstory: String
+}
+
+"""
+A mechanical creature in the Star Wars universe.
+"""
+type Droid implements Character {
+  """
+  The id of the droid.
+  """
+  id: ID!
+
+  """
+  The name of the droid.
+  """
+  name: String
+
+  """
+  The friends of the droid, or an empty list if they have none.
+  """
+  friends: [Character]
+
+  """
+  Which movies they appear in.
+  """
+  appearsIn: [Episode]
+
+  """
+  Construction date and the name of the designer.
+  """
+  secretBackstory: String
+
+  """
+  The primary function of the droid.
+  """
+  primaryFunction: String
+
+  """
+  Chase color of the droid.
+  """
+  color: Color
+}
+
+# One of the films in the Star Wars Trilogy
+enum Episode {
+  """
+  Released in 1977.
+  """
+  NEWHOPE
+
+  """
+  Released in 1980.
+  """
+  EMPIRE
+
+  """
+  Released in 1983.
+  """
+  JEDI
+}
+
+"""
+A humanoid creature in the Star Wars universe.
+"""
+type Human implements Character {
+  """
+  The id of the human.
+  """
+  id: ID!
+
+  """
+  The name of the human.
+  """
+  name: String
+
+  """
+  The friends of the human, or an empty list if they have none.
+  """
+  friends: [Character]
+
+  """
+  Which movies they appear in.
+  """
+  appearsIn: [Episode]
+
+  """
+  The home planet of the human, or null if unknown.
+  """
+  homePlanet: String
+
+  """
+  Where are they from and how they came to be who they are.
+  """
+  secretBackstory: String
+}
+
+enum LengthUnit {
+  METER
+  FEET
+}
+
+type Starship {
+  id: ID!
+  name: String!
+  length(unit: LengthUnit = METER): Float
+}
+
+union SearchResult = Human | Droid | Starship
+
+input SearchInput {
+  name: String
+  episode: Episode
+}
+
+"""
+Root Query
+"""
+type Query {
+  """
+  Return the hero by episode.
+  """
+  hero(
+    """
+    If omitted, returns the hero of the whole saga. If provided, returns the hero of that particular episode.
+    """
+    episode: Episode
+  ): Character
+
+  """
+  Return the Human by ID.
+  """
+  human(
+    """
+    id of the human
+    """
+    id: ID!
+  ): Human
+
+  """
+  Return the Droid by ID.
+  """
+  droid(
+    """
+    id of the droid
+    """
+    id: ID!
+  ): Droid
+
+  """
+  Search everything by name
+
+  __NOTE__: You should use Relay pagination
+  """
+  search(search: SearchInput!): [SearchResult]
+    @deprecated(reason: "`search` will be replaced.")
+}
+
+"""
+Root Mutation
+"""
+type Mutation {
+  """
+  Save the favorite episode.
+  """
+  favorite(
+    """
+    Favorite episode.
+    """
+    episode: Episode!
+  ): Episode
+}
+
+"""
+Subscriptions — live events
+"""
+type Subscription {
+  """
+  Message
+  """
+  message: String
+}
+
+extend type Query {
+  """
+  Dummy query for highlighting test
+  """
+  dummy(
+    int: Int = 123
+    float: Float = 123.456
+    str: String = "Hello World!"
+    boolDefaultTrue: Boolean = true
+    boolDefaultFalse: Boolean = false
+    id: ID
+    search: SearchInput = null
+  ): Boolean
+}
+
+schema {
+  query: Query
+  mutation: Mutation
+  subscription: Subscription
+}
+
+# GraphQL Query Language
+
+query dummyQuery($int: Int) {
+  dummy(int: $int)
+}
+
+mutation favoriteEpisode($episode: Episode) {
+  favorite(episode: $episode)
+}

website/index/samples/sample.html.txt

@@ -1,21 +1,100 @@
 <!DOCTYPE HTML>
-<!--
-	Comments are overrated
--->
+<!--Example of comments in HTML-->
 <html>
 <head>
+	<!--This is the head section-->
 	<title>HTML Sample</title>
+	<meta charset="utf-8">
+
+	<!--This is the style tag to set style on elements-->
 	<style type="text/css">
-		h1 {
-			color: #CCA3A3;
+		h1
+		{
+			font-family: Tahoma;
+			font-size: 40px;
+			font-weight: normal;
+			margin: 50px;
+			color: #a0a0a0;
 		}
+
+		h2
+		{
+			font-family: Tahoma;
+			font-size: 30px;
+			font-weight: normal;
+			margin: 50px;
+			color: #fff;
+		}
+
+		p
+		{
+			font-family: Tahoma;
+			font-size: 17px;
+			font-weight: normal;
+			margin: 0px 200px;
+			color: #fff;
+		}
+
+		div.Center
+		{
+			text-align: center;
+		}
+
+		div.Blue
+		{
+			padding: 50px;
+			background-color: #7bd2ff;
+		}
+
+		button.Gray
+		{
+			font-family: Tahoma;
+			font-size: 17px;
+			font-weight: normal;
+			margin-top: 100px;
+			padding: 10px 50px;
+			background-color: #727272;
+			color: #fff;
+			outline: 0;
+    			border: none;
+    			cursor: pointer;
+		}
+
+		button.Gray:hover
+		{
+			background-color: #898888;
+		}
+
+		button.Gray:active
+		{
+			background-color: #636161;
+		}
+
 	</style>
+
+	<!--This is the script tag-->
 	<script type="text/javascript">
-		window.alert("I am a sample...");
+		function ButtonClick(){
+			// Example of comments in JavaScript
+			window.alert("I'm an alert sample!");
+		}
 	</script>
 </head>
 <body>
-	<h1>Heading No.1</h1>
-	<input disabled type="button" value="Click me" />
+	<!--This is the body section-->
+	<div class="Center">
+		<h1>NAME OF SITE</h1>
+	</div>
+	<div class="Center Blue">
+			<h2>I'm h2 Header! Edit me in &lt;h2&gt;</h2>
+			<p>
+				I'm a paragraph! Edit me in &lt;p&gt;
+				to add your own content and make changes to the style and font.
+				It's easy! Just change the text between &lt;p&gt; ... &lt;/p&gt; and change the style in &lt;style&gt;.
+				You can make it as long as you wish. The browser will automatically wrap the lines to accommodate the
+				size of the browser window.
+			</p>
+			<button class="Gray" onclick="ButtonClick()">Click Me!</button>
+	</div>
 </body>
 </html>

website/index/samples/sample.java.txt

@@ -1,14 +1,54 @@
-import java.util.ArrayList;
-import org.junit.Test;
+/*
+	Basic Java example using FizzBuzz
+*/
+
+import java.util.Random;
 
 public class Example {
-    @Test 
-    public void method() {
-       org.junit.Assert.assertTrue( "isEmpty", new ArrayList<Integer>().isEmpty());
-    }
-	
-   @Test(timeout=100) public void infinity() {
-       while(true);
-    }
- }
+	public static void main (String[] args){
+		// Generate a random number between 1-100. (See generateRandomNumber method.)
+		int random = generateRandomNumber(100);
+
+		// Output generated number.
+		System.out.println("Generated number: " + random + "\n");
+
+		// Loop between 1 and the number we just generated.
+		for (int i=1; i<=random; i++){
+			// If i is divisible by both 3 and 5, output "FizzBuzz".
+			if (i % 3 == 0 && i % 5 == 0){
+				System.out.println("FizzBuzz");
+			}
+			// If i is divisible by 3, output "Fizz"
+			else if (i % 3 == 0){
+				System.out.println("Fizz");
+			}
+			// If i is divisible by 5, output "Buzz".
+			else if (i % 5 == 0){
+				System.out.println("Buzz");
+			}
+			// If i is not divisible by either 3 or 5, output the number.
+			else {
+				System.out.println(i);
+			}
+		}
+	}
+
+	/**
+		Generates a new random number between 0 and 100.
+		@param bound The highest number that should be generated.
+		@return An integer representing a randomly generated number between 0 and 100.
+	*/
+	private static int generateRandomNumber(int bound){
+		// Create new Random generator object and generate the random number.
+		Random randGen = new Random();
+		int randomNum = randGen.nextInt(bound);
+
+		// If the random number generated is zero, use recursion to regenerate the number until it is not zero.
+		if (randomNum < 1){
+			randomNum = generateRandomNumber(bound);
+		}
+
+		return randomNum;
+	}
+}
  

website/index/samples/sample.julia.txt

@@ -0,0 +1,23 @@
+# good style
+function fixedpointmap(f; iv, tolerance=1E-7, maxiter=1000)
+    # setup the algorithm
+    x_old = iv
+    normdiff = Inf
+    iter = 1
+    while normdiff > tolerance && iter <= maxiter
+        x_new = f(x_old) # use the passed in map
+        normdiff = norm(x_new - x_old)
+        x_old = x_new
+        iter = iter + 1
+    end
+    return (value = x_old, normdiff=normdiff, iter=iter) # A named tuple
+end
+
+# define a map and parameters
+p = 1.0
+β = 0.9
+f(v) = p + β * v # note that p and β are used in the function!
+
+sol = fixedpointmap(f, iv=0.8, tolerance=1.0E-8) # don't need to pass
+println("Fixed point = $(sol.value), and |f(x) - x| = $(sol.normdiff) in $(sol.iter)"*
+        " iterations")

website/index/samples/sample.lex.txt

@@ -0,0 +1,21 @@
+LEX Paid Escrow.
+LEXON: 0.2.20
+COMMENT: 3.f - an escrow that is controlled by a third party for a fee.
+
+“Payer” is a person.
+“Payee” is a person.
+“Arbiter” is a person.
+“Fee” is an amount.
+
+The Payer pays an Amount into escrow,
+appoints the Payee,
+appoints the Arbiter,
+and also fixes the Fee.
+
+CLAUSE: Pay Out.
+The Arbiter may pay from escrow the Fee to themselves,
+and afterwards pay the remainder of the escrow to the Payee.
+
+CLAUSE: Pay Back.
+The Arbiter may pay from escrow the Fee to themselves,
+and afterwards return the remainder of the escrow to the Payer.

website/index/samples/sample.markdown.txt

@@ -4,6 +4,13 @@
 ## Markdown plus h2 with a custom ID ##   {#id-goes-here}
 [Link back to H2](#id-goes-here)
 
+```js
+var x = "string";
+function f() {
+  return x;
+}
+```
+
 <!-- html madness -->
 <div class="custom-class" markdown="1">
   <div>
@@ -23,12 +30,12 @@
 - Another one
 + Another one
 
-This is a paragraph, which is text surrounded by 
-whitespace. Paragraphs can be on one 
-line (or many), and can drone on for hours.  
+This is a paragraph, which is text surrounded by
+whitespace. Paragraphs can be on one
+line (or many), and can drone on for hours.
 
-Now some inline markup like _italics_,  **bold**, 
-and `code()`. Note that underscores 
+Now some inline markup like _italics_,  **bold**,
+and `code()`. Note that underscores
 in_words_are ignored.
 
 ````application/json
@@ -57,11 +64,11 @@ if (this_is_more_code == true && !indented) {
 }
 ~~~
 
-Text with  
-two trailing spaces  
-(on the right)  
-can be used  
-for things like poems  
+Text with
+two trailing spaces
+(on the right)
+can be used
+for things like poems
 
 ### Horizontal rules
 
@@ -69,7 +76,7 @@ for things like poems
 ****
 --------------------------
 
-![picture alt](/images/photo.jpeg "Title is optional")     
+![picture alt](/images/photo.jpeg "Title is optional")
 
 ## Markdown plus tables ##
 

website/index/samples/sample.mips.txt

@@ -0,0 +1,13 @@
+# A[i] = A[i/2] + 1;
+    lw     $t0, 0($gp)       # fetch i
+    srl    $t1, $t0, 1       # i/2
+    sll    $t1, $t1, 2       # turn i/2 into a byte offset (*4)
+    add    $t1, $gp, $t1     # &A[i/2] - 28
+    lw     $t1, 28($t1)      # fetch A[i/2]
+    addi   $t1, $t1, 1       # A[i/2] + 1
+    sll    $t2, $t0, 2       # turn i into a byte offset
+    add    $t2, $t2, $gp     # &A[i] - 28
+    sw     $t1, 28($t2)      # A[i] = ...
+# A[i+1] = -1;
+    addi   $t1, $zero, -1    # -1
+    sw     $t1, 32($t2)      # A[i+1] = -1

website/index/samples/sample.pascal.txt

@@ -25,4 +25,4 @@ begin
     on E: Exception do
       Writeln(E.ClassName, ': ', E.Message);
   end;
-end.
+end.

website/index/samples/sample.pascaligo.txt

@@ -0,0 +1,20 @@
+type storage is int
+type parameter is
+  Increment of int
+| Decrement of int
+| Reset
+type return is list (operation) * storage
+// Two entrypoints
+function add (const store : storage; const delta : int) : storage is
+  store + delta
+function sub (const store : storage; const delta : int) : storage is
+  store - delta
+(* Main access point that dispatches to the entrypoints according to
+   the smart contract parameter. *)
+function main (const action : parameter; const store : storage) : return is
+ ((nil : list (operation)),    // No operations
+  case action of
+    Increment (n) -> add (store, n)
+  | Decrement (n) -> sub (store, n)
+  | Reset         -> 0
+  end)

website/index/samples/sample.restructuredtext.txt

@@ -0,0 +1,26 @@
+=================
+My Project Readme
+=================
+-------------------------
+Clever subtitle goes here
+-------------------------
+
+Introduction
+============
+
+This is an example reStructuredText document that starts at the very top
+with a title and a sub-title. There is one primary header, Introduction.
+There is one example subheading below.
+The document is just plain text so it is easily readable even before
+being converted to HTML, man page, PDF or other formats.
+
+Subheading
+----------
+
+The basic syntax is not that different from Markdown, but it also
+has many more powerful features that Markdown doesn't have. We aren't
+taking advantage of those yet though.
+
+- Bullet points
+- Are intuitive
+- And simple too

website/index/samples/sample.scala.txt

@@ -0,0 +1,53 @@
+package examples
+
+/** Quick sort, imperative style */
+object sort {
+
+  /** Nested methods can use and even update everything
+   *  visible in their scope (including local variables or
+   *  arguments of enclosing methods).
+   */
+  def sort(a: Array[Int]) {
+
+    def swap(i: Int, j: Int) {
+      val t = a(i); a(i) = a(j); a(j) = t
+    }
+
+    def sort1(l: Int, r: Int) {
+      val pivot = a((l + r) / 2)
+      var i = l
+      var j = r
+      while (i <= j) {
+        while (a(i) < pivot) i += 1
+        while (a(j) > pivot) j -= 1
+        if (i <= j) {
+          swap(i, j)
+          i += 1
+          j -= 1
+        }
+      }
+      if (l < j) sort1(l, j)
+      if (j < r) sort1(i, r)
+    }
+
+    if (a.length > 0)
+      sort1(0, a.length - 1)
+  }
+
+  def println(ar: Array[Int]) {
+    def print1 = {
+      def iter(i: Int): String =
+        ar(i) + (if (i < ar.length-1) "," + iter(i+1) else "")
+      if (ar.length == 0) "" else iter(0)
+    }
+    Console.println("[" + print1 + "]")
+  }
+
+  def main(args: Array[String]) {
+    val ar = Array(6, 2, 8, 5, 1)
+    println(ar)
+    sort(ar)
+    println(ar)
+  }
+
+}

website/index/samples/sample.systemverilog.txt

@@ -0,0 +1,28 @@
+// File : tb_top.sv
+module tb_top ();
+
+	reg clk;
+	reg resetn;
+	reg d;
+	wire q;
+
+	// Instantiate the design
+	d_ff  d_ff0 (	.clk (clk),
+		       		.resetn (resetn),
+		       		.d (d),
+		       		.q (q));
+
+	// Create a clock
+	always #10 clk <= ~clk;
+
+	initial begin
+		resetn <= 0;
+		d <= 0;
+
+		#10 resetn <= 1;
+		#5      d <= 1;
+		#8      d <= 0;
+		#2      d <= 1;
+		#10     d <= 0;
+	end
+endmodule

website/index/samples/sample.tcl.txt

@@ -0,0 +1,18 @@
+proc find {{basedir .} {filterScript {}}} {
+    set oldwd [pwd]
+    cd $basedir
+    set cwd [pwd]
+    set filenames [glob -nocomplain * .*]
+    set files {}
+    set filt [string length $filterScript]
+    foreach filename $filenames {
+        if {!$filt || [eval $filterScript [list $filename]]} {
+            lappend files [file join $cwd $filename]
+        }
+        if {[file isdirectory $filename]} {
+            set files [concat $files [find $filename $filterScript]]
+        }
+    }
+    cd $oldwd
+    return $files
+}

website/index/samples/sample.twig.txt

@@ -0,0 +1,12 @@
+<!DOCTYPE html>
+<html>
+    <head>
+        <meta charset="UTF-8">
+        <title>{% block title %}Welcome!{% endblock %}</title>
+        {% block stylesheets %}{% endblock %}
+    </head>
+    <body>
+        {% block body %}{% endblock %}
+        {% block javascripts %}{% endblock %}
+    </body>
+</html>

website/index/samples/sample.typescript.txt

@@ -2,21 +2,21 @@
  * Implemented in TypeScript
  * To learn more about TypeScript, please visit http://www.typescriptlang.org/
  */
- 
-module Conway {
+
+namespace Conway {
 
 	export class Cell {
 		public row: number;
 		public col: number;
 		public live: boolean;
-		
+
 		constructor(row: number, col: number, live: boolean) {
 			this.row = row;
 			this.col = col;
-			this.live = live
+			this.live = live;
 		}
 	}
-	
+
 	export class GameOfLife {
 		private gridSize: number;
 		private canvasSize: number;
@@ -28,8 +28,8 @@ module Conway {
 		private cellSize: number;
 		private context: CanvasRenderingContext2D;
 		private world;
-		
-		
+
+
 		constructor() {
 			this.gridSize = 50;
 			this.canvasSize = 600;
@@ -42,14 +42,14 @@ module Conway {
 			this.world = this.createWorld();
 			this.circleOfLife();
 		}
-	
+
 		public createWorld() {
 			return this.travelWorld( (cell : Cell) =>  {
 				cell.live = Math.random() < this.initialLifeProbability;
 				return cell;
 			});
 		}
-		
+
 		public circleOfLife() : void {
 			this.world = this.travelWorld( (cell: Cell) => {
 				cell = this.world[cell.row][cell.col];
@@ -57,8 +57,8 @@ module Conway {
 				return this.resolveNextGeneration(cell);
 			});
 			setTimeout( () => {this.circleOfLife()}, this.animationRate);
-		} 
-	
+		}
+
 		public resolveNextGeneration(cell : Cell) {
 			var count = this.countNeighbors(cell);
 			var newCell = new Cell(cell.row, cell.col, cell.live);
@@ -66,7 +66,7 @@ module Conway {
 			else if(count == 3) newCell.live = true;
 			return newCell;
 		}
-	
+
 		public countNeighbors(cell : Cell) {
 			var neighbors = 0;
 			for(var row = -1; row <=1; row++) {
@@ -79,12 +79,12 @@ module Conway {
 			}
 			return neighbors;
 		}
-	
+
 		public isAlive(row : number, col : number) {
 			if(row < 0 || col < 0 || row >= this.gridSize || col >= this.gridSize) return false;
 			return this.world[row][col].live;
 		}
-	
+
 		public travelWorld(callback) {
 			var result = [];
 			for(var row = 0; row < this.gridSize; row++) {
@@ -93,20 +93,20 @@ module Conway {
 					rowData.push(callback(new Cell(row, col, false)));
 				}
 				result.push(rowData);
-			}  
+			}
 			return result;
 		}
-	
+
 		public draw(cell : Cell) {
 			if(this.context == null) this.context = this.createDrawingContext();
 			if(this.cellSize == 0) this.cellSize = this.canvasSize/this.gridSize;
-	
+
 			this.context.strokeStyle = this.lineColor;
 			this.context.strokeRect(cell.row * this.cellSize, cell.col*this.cellSize, this.cellSize, this.cellSize);
 			this.context.fillStyle = cell.live ? this.liveColor : this.deadColor;
 			this.context.fillRect(cell.row * this.cellSize, cell.col*this.cellSize, this.cellSize, this.cellSize);
-		}    
-		
+		}
+
 		public createDrawingContext() {
 			var canvas = <HTMLCanvasElement> document.getElementById('conway-canvas');
 			if(canvas == null) {

website/index/samples/sample.verilog.txt

@@ -0,0 +1,35 @@
+`include "first_counter.v"
+module first_counter_tb();
+// Declare inputs as regs and outputs as wires
+reg clock, reset, enable;
+wire [3:0] counter_out;
+
+// Initialize all variables
+initial begin
+  $display ("time\t clk reset enable counter");
+  $monitor ("%g\t %b   %b     %b      %b",
+	  $time, clock, reset, enable, counter_out);
+  clock = 1;       // initial value of clock
+  reset = 0;       // initial value of reset
+  enable = 0;      // initial value of enable
+   #5  reset = 1;    // Assert the reset
+   #10  reset = 0;   // De-assert the reset
+   #10  enable = 1;  // Assert enable
+   #100  enable = 0; // De-assert enable
+   #5  $finish;      // Terminate simulation
+end
+
+// Clock generator
+always begin
+   #5  clock = ~clock; // Toggle clock every 5 ticks
+end
+
+// Connect DUT to test bench
+first_counter U_counter (
+clock,
+reset,
+enable,
+counter_out
+);
+
+endmodule