# SyntaxHighlighter v4.0.1

# applescript

    -- Dialog
    set dialogReply to display dialog "Dialog Text" ¬
      default answer "Text Answer" ¬
      hidden answer false ¬
      buttons {"Skip", "Okay", "Cancel"} ¬
      default button "Okay" ¬
      cancel button "Skip" ¬
      with title "Dialog Window Title" ¬
      with icon note ¬
      giving up after 15

    display alert "Hello, world!" buttons {"Rudely decline", "Happily accept"}
    set theAnswer to button returned of the result
    if theAnswer is "Happily accept" then
      beep 5
    else
      say "Piffle!"
    end if

# as3

    /*
      Copyright (c) 2009, Adobe Systems Incorporated
      All rights reserved.

      Redistribution and use in source and binary forms, with or without
      modification, are permitted provided that the following conditions are
      met:

      * Redistributions of source code must retain the above copyright notice,
        this list of conditions and the following disclaimer.

      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.

      * Neither the name of Adobe Systems Incorporated nor the names of its
        contributors may be used to endorse or promote products derived from
        this software without specific prior written permission.

      THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
      IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
      THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
      PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
      CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
      EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
      PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
      PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
      LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
      NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
      SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
    */

    package com.adobe.air.crypto
    {
      import com.adobe.crypto.SHA256;

      import flash.data.EncryptedLocalStore;
      import flash.utils.ByteArray;

      /**
       * The EncryptionKeyGenerator class generates an encryption key value, such as you would use
       * to encrypt files or data. For example, the encryption key is suitable to use as
       * an encryption key for an encrypted AIR local SQL (SQLite) database.
       *
       * <p>This class uses techniques and algorithms that are designed for maximum
       * data privacy and security. Use this class to generate an encryption key if your
       * application requires data to be encrypted on a per-user level (in other words,
       * if only one user of the application should be able to access his or her data).
       * In some situations you may also want to use per-user encryption for data even
       * if the application design specifies that other users can access the data. For more
       * information, see
       * "<a href="http://help.adobe.com/en_US/AIR/1.5/devappsflex/WS34990ABF-C893-47ec-B813-9C9D9587A398.html">Considerations for using encryption with a database</a>"
       * in the guide
       * "<a href="http://help.adobe.com/en_US/AIR/1.5/devappsflex/">Developing Adobe AIR Applications with Flex</a>."</p>
       *
       * <p>The generated encryption key is based on a password that you provide. For any given
       * password, in the same AIR application
       * running in the same user account on the same machine, the encryption key result is
       * the same.</p>
       *
       * <p>To generate an encryption key from a password, use the <code>getEncryptionKey()</code>
       * method. To confirm that a password is a "strong" password before calling the
       * <code>getEncryptionKey()</code> method, use the <code>validateStrongPassword()</code>
       * method.</p>
       *
       * <p>In addition, the EncryptionKeyGenerator includes a utility constant,
       * <code>ENCRYPTED_DB_PASSWORD_ERROR_ID</code>. This constant matches the error ID of
       * the SQLError error that occurs when code that is attempting to open an encrypted database
       * provides the wrong encryption key.</p>
       *
       * <p>This class is designed to create an encryption key suitable for providing the highest
       * level of data privacy and security. In order to achieve that level of security, a few
       * security principles must be followed:</p>
       *
       * <ul>
       *   <li>Your application should never store the user-entered password</li>
       *   <li>Your application should never store the encryption key returned by the
       *       <code>getEncryptionKey()</code> method.</li>
       *   <li>Instead, each time the user runs the application and attempts to access the database,
       *       your application code should call the <code>getEncryptionKey()</code> method to
       *       regenerate the encryption key.</li>
       * </ul>
       *
       * <p>For more information about data security, and an explanation of the security techniques
       * used in the EncryptionKeyGenerator class, see
       * "<a href="http://help.adobe.com/en_US/AIR/1.5/devappsflex/WS61068DCE-9499-4d40-82B8-B71CC35D832C.html">Example: Generating and using an encryption key</a>"
       * in the guide
       * "<a href="http://help.adobe.com/en_US/AIR/1.5/devappsflex/">Developing Adobe AIR Applications with Flex</a>."</p>
       */
      public class EncryptionKeyGenerator
      {
          // ------- Constants -------
          /**
           * This constant matches the error ID (3138) of the SQLError error that occurs when
           * code that is attempting to open an encrypted database provides the wrong
           * encryption key.
           */
          public static const ENCRYPTED_DB_PASSWORD_ERROR_ID:uint = 3138;

          private static const STRONG_PASSWORD_PATTERN:RegExp = /(?=^.{8,32}$)((?=.*\d)|(?=.*\W+))(?![.\n])(?=.*[A-Z])(?=.*[a-z]).*$/;
          private static const SALT_ELS_KEY:String = "com.adobe.air.crypto::EncryptedDBSalt$$$";

          // ------- Constructor -------

          /**
           * Creates a new EncryptionKeyGenerator instance.
           */
          public function EncryptionKeyGenerator() {}

          // ------- Public methods -------

          /**
           * Checks a password and returns a value indicating whether the password is a "strong"
           * password. The criteria for a strong password are:
           *
           * <ul>
           *   <li>Minimum 8 characters</li>
           *   <li>Maxmium 32 characters</li>
           *   <li>Contains at least one lowercase letter</li>
           *   <li>Contains at least one uppercase letter</li>
           *   <li>Contains at least one number or symbol character</li>
           * </ul>
           *
           * @param password The password to check
           *
           * @return A value indicating whether the password is a strong password (<code>true</code>)
           * or not (<code>false</code>).
           */
          public function validateStrongPassword(password:String):Boolean
          {
              if (password == null || password.length <= 0)
              {
                  return false;
              }

              return STRONG_PASSWORD_PATTERN.test(password);
          }

          /**
           * Uses a password to generate a 16-byte encryption key. The return value is suitable
           * to use as an encryption key for an encrypted AIR local SQL (SQLite) database.
           *
           * <p>For any given
           * password, calling the <code>getEncryptionKey()</code> method from the same AIR application
           * running in the same user account on the same machine, the encryption key result is
           * the same.
           *
           * <p>This method is designed to create an encryption key suitable for providing the highest
           * level of data privacy and security. In order to achieve that level of security, your
           * application must follow several security principles:</p>
           *
           * <ul>
           *   <li>Your application can never store the user-entered password</li>
           *   <li>Your application can never store the encryption key returned by the
           *       <code>getEncryptionKey()</code> method.</li>
           *   <li>Instead, each time the user runs the application and attempts to access the database,
           *       call the <code>getEncryptionKey()</code> method to regenerate the encryption key.</li>
           * </ul>
           *
           * <p>For more information about data security, and an explanation of the security techniques
           * used in the EncryptionKeyGenerator class, see
           * "<a href="http://help.adobe.com/en_US/AIR/1.5/devappsflex/WS61068DCE-9499-4d40-82B8-B71CC35D832C.html">Example: Generating and using an encryption key</a>"
           * in the guide
           * "<a href="http://help.adobe.com/en_US/AIR/1.5/devappsflex/">Developing Adobe AIR Applications with Flex</a>."</p>
           *
           * @param password  The password to use to generate the encryption key.
           * @param overrideSaltELSKey    The EncryptionKeyGenerator creates and stores a random value
           *                              (known as a <i>salt</i>) as part of the process of
           *                              generating the encryption key. The first time an application
           *                              calls the <code>getEncryptionKey()</code> method, the salt
           *                              value is created and stored in the AIR application's encrypted
           *                              local store (ELS). From then on, the salt value is loaded from the
           *                              ELS.
           *                              <p>If you wish to provide a custom String ELS key for storing
           *                              the salt value, specify a value for the <code>overrideSaltELSKey</code>
           *                              parameter. If the parameter is <code>null</code> (the default)
           *                              a default key name is used.</p>
           *
           * @return The generated encryption key, a 16-byte ByteArray object.
           *
           * @throws ArgumentError    If the specified password is not a "strong" password according to the
           *                          criteria explained in the <code>validateStrongPassword()</code>
           *                          method description
           *
           * @throws ArgumentError    If a non-<code>null</code> value is specified for the <code>overrideSaltELSKey</code>
           *                          parameter, and the value is an empty String (<code>""</code>)
           */
          public function getEncryptionKey(password:String, overrideSaltELSKey:String=null):ByteArray
          {
              if (!validateStrongPassword(password))
              {
                  throw new ArgumentError("The password must be a strong password. It must be 8-32 characters long. It must contain at least one uppercase letter, at least one lowercase letter, and at least one number or symbol.");
              }

              if (overrideSaltELSKey != null && overrideSaltELSKey.length <= 0)
              {
                  throw new ArgumentError("If an overrideSaltELSKey parameter value is specified, it can't be an empty String.");
              }

              var concatenatedPassword:String = concatenatePassword(password);

              var saltKey:String;
              if (overrideSaltELSKey == null)
              {
                  saltKey = SALT_ELS_KEY;
              }
              else
              {
                  saltKey = overrideSaltELSKey;
              }

              var salt:ByteArray = EncryptedLocalStore.getItem(saltKey);
              if (salt == null)
              {
                  salt = makeSalt();
                  EncryptedLocalStore.setItem(saltKey, salt);
              }

              var unhashedKey:ByteArray = xorBytes(concatenatedPassword, salt);

              var hashedKey:String = SHA256.hashBytes(unhashedKey);

              var encryptionKey:ByteArray = generateEncryptionKey(hashedKey);

              return encryptionKey;
          }

          // ------- Creating encryption key -------

          private function concatenatePassword(pwd:String):String
          {
              var len:int = pwd.length;
              var targetLength:int = 32;

              if (len == targetLength)
              {
                  return pwd;
              }

              var repetitions:int = Math.floor(targetLength / len);
              var excess:int = targetLength % len;

              var result:String = "";

              for (var i:uint = 0; i < repetitions; i++)
              {
                  result += pwd;
              }

              result += pwd.substr(0, excess);

              return result;
          }

          private function makeSalt():ByteArray
          {
              var result:ByteArray = new ByteArray;

              for (var i:uint = 0; i < 8; i++)
              {
                  result.writeUnsignedInt(Math.round(Math.random() * uint.MAX_VALUE));
              }

              return result;
          }

          private function xorBytes(passwordString:String, salt:ByteArray):ByteArray
          {
              var result:ByteArray = new ByteArray();

              for (var i:uint = 0; i < 32; i += 4)
              {
                  // Extract 4 bytes from the password string and convert to a uint
                  var o1:uint = passwordString.charCodeAt(i) << 24;
                  o1 += passwordString.charCodeAt(i + 1) << 16;
                  o1 += passwordString.charCodeAt(i + 2) << 8;
                  o1 += passwordString.charCodeAt(i + 3);

                  salt.position = i;
                  var o2:uint = salt.readUnsignedInt();

                  var xor:uint = o1 ^ o2;
                  result.writeUnsignedInt(xor);
              }

              return result;
          }

          private function generateEncryptionKey(hash:String):ByteArray
          {
              var result:ByteArray = new ByteArray();

              // select a range of 128 bits (32 hex characters) from the hash
              // In this case, we'll use the bits starting from position 17
              for (var i:uint = 0; i < 32; i += 2)
              {
                  var position:uint = i + 17;
                  var hex:String = hash.substr(position, 2);
                  var byte:int = parseInt(hex, 16);
                  result.writeByte(byte);
              }

              return result;
          }
      }
    }

# base

    no sample.txt found

# bash

    #!/bin/bash
    X=3
    Y=4
    empty_string=""
    if [ $X -lt $Y ]  # is $X less than $Y ?
    then
      echo "\$X=${X}, which is smaller than \$Y=${Y}"
    fi

    if [ -n "$empty_string" ]; then
      echo "empty string is non_empty"
    fi

    if [ -e "${HOME}/.fvwmrc" ]; then             # test to see if ~/.fvwmrc exists
      echo "you have a .fvwmrc file"
      if [ -L "${HOME}/.fvwmrc" ]; then       # is it a symlink ?
          echo "it's a symbolic link"
      elif [ -f "${HOME}/.fvwmrc" ]; then     # is it a regular file ?
          echo "it's a regular file"
      fi
    else
      echo "you have no .fvwmrc file"
    fi

# coldfusion

    <!--- temperature.cfc --->
    <cfcomponent>
      <cffunction name="FtoC" access="public" returntype="numeric">
        <cfargument name="fahrenheit" required="yes" type="numeric" />
        <cfset answer= (fahrenheit - 32)*100/180 />
        <cfreturn answer />
      </cffunction>
    </cfcomponent>
    <!--- test.cfm --->
    <cfset fDegrees = 212 />
    <cfinvoke component="temperature" method="FtoC" returnvariable="result">
      <cfinvokeargument name="fahrenheit" value="#fDegrees#" />
    </cfinvoke>
    <cfoutput>#fDegrees#&deg;F = #result#&deg;C</cfoutput> <br />

# cpp

    /* $Id: main.cpp,v 1.1 2004/01/25 22:57:25 zongo Exp $
    **
    ** Ark - Libraries, Tools & Programs for MORPG developpements.
    ** Copyright (C) 1999-2004 The Contributors of the Ark Project
    ** Please see the file "AUTHORS" for a list of contributors
    **
    ** This program is free software; you can redistribute it and/or modify
    ** it under the terms of the GNU General Public License as published by
    ** the Free Software Foundation; either version 2 of the License, or
    ** (at your option) any later version.
    **
    ** This program is distributed in the hope that it will be useful,
    ** but WITHOUT ANY WARRANTY; without even the implied warranty of
    ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    ** GNU General Public License for more details.
    **
    ** You should have received a copy of the GNU General Public License
    ** along with this program; if not, write to the Free Software
    ** Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
    */

    #include <iostream>
    #include <sstream>

    #include <string>

    #include "xmlRead.h"
    #include "ogreGeometryReader.h"
    #include "ogreMeshReader.h"

    /****************************************************************************/

    class OgreSkeletonReader
    {
      std::ostream& errors;

    public:
      OgreSkeletonReader(std::ostream& e) : errors(e) {}
      void parse(XmlNode& root)
      {
      }

      bool write(std::ostream& os)
      {
          return true;
      }
    };

    /****************************************************************************/
    void parseStory (XmlNode& node)
    {
      for (XmlNode cur=node.firstChild() ; cur ; cur=cur.nextSibling())
      {
          if (cur.isName("keyword"))
          {
              std::string key = cur.getString();
              std::cout << "keyword: " << key << std::endl;
          }
      }
    }

    void parseDocument(const char *filename)
    {
      XmlDocument doc(filename);

      if (!doc)
      {
          std::cerr << "Document not parsed successfully." << std::endl;
          return;
      }

      XmlNode root(doc);
      if (!root)
      {
          std::cerr << "Empty document." << std::endl;
          return;
      }

      if (root.isName("mesh"))
      {
          MeshParameters defaults;
          OgreMeshReader mesh(std::cerr, defaults);
          mesh.parseMesh(root);
          mesh.write(std::cout);
      }
      else if (root.isName("skeleton"))
      {
          OgreSkeletonReader skel(std::cerr);
          skel.parse(root);
          skel.write(std::cout);
      }
      else
      {
          std::cerr << "Unsupported XML file." << std::endl;
      }
    }

    int main(int argc, char **argv)
    {
      if (argc <= 1)
      {
          std::cerr << "Usage: " << argv[0] << " file.xml" << std::endl;
          return -1;
      }

      const char* filename = argv[1];
      parseDocument(filename);

      return 0;
    }

# csharp

    using System;
    using System.Text.RegularExpressions;

    namespace SharpVectors.Dom.Css
    {
      /// <summary>
      /// The CSSFontFaceRule interface represents a @font-face rule in a CSS style sheet. The @font-face rule is used to hold a set of font descriptions.
      /// </summary>
      /// <developer>niklas@protocol7.com</developer>
      /// <completed>80</completed>
      public class CssFontFaceRule : CssRule, ICssFontFaceRule
      {
          #region Static members
          private static Regex regex = new Regeх(@"^@font-face");

          /// <summary>
          /// Parses a string containging CSS and creates a CssFontFaceRule instance if found as the first content
          /// </summary>
          internal static CssRule Parse(ref string css, object parent, bool readOnly, string[] replacedStrings, CssStyleSheetType origin)
          {
              Match match = regex.Match(css);
              if(match.Success)
              {
                  CssFontFaceRule rule = new CssFontFaceRule(match, parent, readOnly, replacedStrings, origin);
                  css = css.Substring(match.Length);

                  rule.style = new CssStyleDeclaration(ref css, rule, true, origin);

                  return rule;
              }
              else
              {
                  // didn't match => do nothing
                  return null;
              }
          }
          #endregion

          #region Constructors
          /// <summary>
          /// The constructor for CssFontFaceRule
          /// </summary>
          /// <param name="match">The Regex match that found the charset rule</param>
          /// <param name="parent">The parent rule or parent stylesheet</param>
          /// <param name="readOnly">True if this instance is readonly</param>
          /// <param name="replacedStrings">An array of strings that have been replaced in the string used for matching. These needs to be put back use the DereplaceStrings method</param>
          /// <param name="origin">The type of CssStyleSheet</param>
          internal CssFontFaceRule(Match match, object parent, bool readOnly, string[] replacedStrings, CssStyleSheetType origin) : base(parent, true, replacedStrings, origin)
          {
              // always read-only

          }
          #endregion

          #region Implementation of ICssFontFaceRule
          private CssStyleDeclaration style;
          /// <summary>
          /// The declaration-block of this rule.
          /// </summary>
          public ICssStyleDeclaration Style
          {
              get
              {
                  return style;
              }
          }
          #endregion

          #region Implementation of ICssRule
          /// <summary>
          /// The type of the rule. The expectation is that binding-specific casting methods can be used to cast down from an instance of the CSSRule interface to the specific derived interface implied by the type.
          /// </summary>
          public override CssRuleType Type
          {
              get
              {
                  return CssRuleType.FontFaceRule;
              }
          }
          #endregion
      }
    }

# css

    .syntaxhighlighter,
    .syntaxhighlighter .bold,
    .syntaxhighlighter .italic,
    .syntaxhighlighter .line .number,
    .syntaxhighlighter.nogutter .line .number,
    .syntaxhighlighter .line .content,
    .syntaxhighlighter .line .content code,
    .syntaxhighlighter .line .content .block,
    .syntaxhighlighter .line .content .spaces,
    .syntaxhighlighter.nogutter .line .content,
    .syntaxhighlighter .bar,
    .syntaxhighlighter.collapsed .bar,
    .syntaxhighlighter.nogutter .bar,
    .syntaxhighlighter .ruler,
    .syntaxhighlighter.collapsed .lines,
    .syntaxhighlighter.collapsed .ruler,
    .syntaxhighlighter.printing,
    .syntaxhighlighter.printing .tools,
    .syntaxhighlighter.printing li,
    .syntaxhighlighter .toolbar,
    .syntaxhighlighter.nogutter .toolbar,
    .syntaxhighlighter.collapsed .toolbar,
    .syntaxhighlighter .toolbar a,
    .syntaxhighlighter .toolbar a:hover
    {
      margin: 0;
      padding: 0;
      border: 0;
      outline: 0;
      background: none;
      text-align: left;
      float: none;
      vertical-align: baseline;
      position: static;
      left: auto;
      top: auto;
      right: auto;
      bottom: auto;
      height: auto;
      width: auto;
      line-height: normal;
      font-family: "Consolas", "Monaco", "Bitstream Vera Sans Mono", "Courier New", Courier, monospace;
      font-weight: normal;
      font-style: normal;
      font-size: 100%;
    }

    .syntaxhighlighter
    {
      font-size: 16px;
      width: 99%;
      overflow: auto;
      margin: 18px 0 18px 0 !important;
      padding-top: 1px; /* adds a little border on top when controls are hidden */
    }

    .syntaxhighlighter .bold {
      font-weight: bold;
    }

    .syntaxhighlighter .italic {
      font-style: italic;
    }

    .syntaxhighlighter .line .number
    {
      float: left;
      width: 45px;
      padding-right: 5px;
      text-align: right;
      display: block;
    }

    /* Disable numbers when no gutter option is set */
    .syntaxhighlighter.nogutter .line .number
    {
      display: none;
    }

    .syntaxhighlighter .line .content
    {
      margin-left: 50px;
      padding-left: 4px;
      display: block;
    }

    .syntaxhighlighter .line .content .block
    {
      display: block;
      padding-left: 18px;
      text-indent: -18px;
    }

    .syntaxhighlighter .line .content .spaces
    {
      display: none;
    }

    /* Disable border and margin on the lines when no gutter option is set */
    .syntaxhighlighter.nogutter .line .content
    {
      margin-left: 0;
      border-left: none;
    }

    .syntaxhighlighter .bar
    {
      padding-left: 50px;
    }

    .syntaxhighlighter.collapsed .bar,
    .syntaxhighlighter.nogutter .bar
    {
      padding-left: 0px;
    }

    .syntaxhighlighter .ruler
    {
      padding-left: 4px;
      overflow: hidden;
      padding-bottom: 2px;
    }

    /* Adjust some properties when collapsed */

    .syntaxhighlighter.collapsed .lines,
    .syntaxhighlighter.collapsed .ruler
    {
      display: none;
    }

    /* Additional modifications when in print-view */

    .syntaxhighlighter.printing
    {
      border: none !important;
    }

    .syntaxhighlighter.printing .bar
    {
      display: none !important;
    }

    /* Styles for the tools */

    .syntaxhighlighter .toolbar
    {
      font-size: 80%;
      font-family: Geneva, Verdana, Arial, Helvetica, sans-serif;
      padding: 1px 5px 5px 5px;
    }

    .syntaxhighlighter.nogutter .toolbar
    {
      border-left: 0;
    }

    .syntaxhighlighter.collapsed .toolbar
    {
      border-bottom: 0;
    }

    .syntaxhighlighter .toolbar a
    {
      text-decoration: none;
      margin-right: 10px;
    }

    .syntaxhighlighter .toolbar a:hover
    {
      text-decoration: underline;
      margin-right: 10px;
    }

# delphi

    { $OmniXML: OmniXML/extras/OmniXMLShared.pas,v 1.1 2004/06/07 13:06:32 mr Exp $ }

    {$WEAKPACKAGEUNIT ON}

    (*:XML helper unit. Contains class to manage shared XML document (stored in the
       resizable shared memory).
       @author Primoz Gabrijelcic
       @desc <pre>
       (c) 2002 Primoz Gabrijelcic
       Free for personal and commercial use. No rights reserved.

       Author            : Primoz Gabrijelcic
       Creation date     : 2002-05-13
       Last modification : 2002-09-24
       Version           : 1.01
    </pre>*)(*
       History:
         1.01: 2002-09-24
           - Added property TGpSharedXML.CachedXML.
         1.0: 2002-05-13
           - Created.
    *)

    unit OmniXMLShared;

    interface

    uses
      Windows,
      GpSharedMemory,
      OmniXMLProperties;

    type
      {:Shared XML document.
      }
      TGpSharedXML = class
      private
        sxOwnsXML     : boolean;
        sxSharedMemory: TGpSharedMemory;
        sxXMLDoc      : TGpXMLDoc;
      protected
        function  Acquire(forWriting: boolean; timeout: DWORD): TGpXMLDoc;
        function  GetName: string;
        function  GetXML: TGpXMLDoc;
      public
        constructor Create(sharedMemoryName: string; xmlDoc: TGpXMLDoc;
          maxSize: cardinal; ownsXML: boolean = true); virtual;
        destructor  Destroy; override;
        function  BeginUpdate(timeout: DWORD): TGpXMLDoc; virtual;
        procedure EndUpdate; virtual;
        function  Read(timeout: DWORD): TGpXMLDoc; virtual;
        property  CachedXML: TGpXMLDoc read sxXMLDoc;
        property  Name: string read GetName;
        property  XML: TGpXMLDoc read GetXML;
      end; { TGpSharedXML }

      {:Shared XML list.
      }
      TGpSharedXMLList = class(TGpSharedXML)
      public
        constructor Create(sharedMemoryName: string; xmlList: TGpXMLDocList;
          maxSize: cardinal; ownsXML: boolean = true); reintroduce; virtual;
        function Count: integer;
      end; { TGpSharedXMLList }

    implementation

    uses
    {$IFDEF DebugXML}
      OmniXMLUtils,
      uDbg,
    {$ENDIF DebugXML}
      SysUtils;

    { TGpSharedXML }

    function TGpSharedXML.Acquire(forWriting: boolean;
      timeout: DWORD): TGpXMLDoc;
    begin
      Result := nil;
      if sxSharedMemory.AcquireMemory(forWriting, timeout) <> nil then begin
          if (not sxSharedMemory.Modified) or
             sxXMLDoc.LoadFromStream(sxSharedMemory.AsStream)
          then
            Result := sxXMLDoc;
        if not assigned(Result) then
          sxSharedMemory.ReleaseMemory;
        {$IFDEF DebugXML}
        if assigned(Result) then
          Debugger.LogFmtMsg('Acquire: %s',[XMLSaveToString(sxXMLDoc.XMLDoc)]);
        {$ENDIF DebugXML}
      end;
    end; { TGpSharedXML.Acquire }

    function TGpSharedXML.BeginUpdate(timeout: DWORD): TGpXMLDoc;
    begin
      Result := Acquire(true, timeout);
    end; { TGpSharedXML.BeginUpdate }

    constructor TGpSharedXML.Create(sharedMemoryName: string; xmlDoc: TGpXMLDoc;
      maxSize: cardinal; ownsXML: boolean);
    begin
      inherited Create;
      sxSharedMemory := TGpSharedMemory.Create(sharedMemoryName, 0, maxSize);
      sxXMLDoc := xmlDoc;
      sxOwnsXML := ownsXML;
    end; { TGpSharedXML.Create }

    destructor TGpSharedXML.Destroy;
    begin
      if sxOwnsXML then
        FreeAndNil(sxXMLDoc)
      else
        sxXMLDoc := nil;
      FreeAndNil(sxSharedMemory);
      inherited;
    end; { TGpSharedXML.Destroy }

    procedure TGpSharedXML.EndUpdate;
    begin
      {$IFDEF DebugXML}
      Debugger.LogFmtMsg('Release: %s',[XMLSaveToString(sxXMLDoc.XMLDoc)]);
      {$ENDIF DebugXML}
      if sxSharedMemory.IsWriting then
        sxXMLDoc.SaveToStream(sxSharedMemory.AsStream);
      if sxSharedMemory.Acquired then
        sxSharedMemory.ReleaseMemory;
    end; { TGpSharedXML.EndUpdate }

    function TGpSharedXML.GetName: string;
    begin
      Result := sxSharedMemory.Name;
    end; { TGpSharedXML.GetName }

    function TGpSharedXML.GetXML: TGpXMLDoc;
    begin
      if not sxSharedMemory.Acquired then
        Result := nil
      else
        Result := sxXMLDoc;
    end; { TGpSharedXML.GetXML }

    function TGpSharedXML.Read(timeout: DWORD): TGpXMLDoc;
    begin
      Result := Acquire(false, timeout);
      EndUpdate;
    end; { TGpSharedXML.Read }

    { TGpSharedXMLList }

    function TGpSharedXMLList.Count: integer;
    begin
      Result := (XML as TGpXMLDocList).Count;
    end; { TGpSharedXMLList.Count }

    constructor TGpSharedXMLList.Create(sharedMemoryName: string;
      xmlList: TGpXMLDocList; maxSize: cardinal; ownsXML: boolean);
    begin
      inherited Create(sharedMemoryName, xmlList, maxSize, ownsXML);
    end; { TGpSharedXMLList.Create }

    {$IFDEF DebugXML}
    initialization
      NxStartDebug;
    finalization
      NxEndDebug;
    {$ENDIF DebugXML}
    end.

# diff

    --- ...\index.php-rev104.svn000.tmp.php   2008-10-13 20:34:44.000000000 -0300
    +++ ...\index.php 2008-10-13 16:31:46.000000000 -0300
    @@ -90,36 +90,34 @@
             \$url .= \$arg;
         }

         return \$url;
     }

    -//<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
    -//<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
     ?>
    -<!DOCTYPE html
    -     PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
    -     "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
    +<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
     <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
     <head>
     <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
     <title>SyntaxHighlighter</title>
     <link type="text/css" rel="stylesheet" href="Styles/shCore.css"/>
     <link type="text/css" rel="stylesheet" href="Styles/shTheme<?= \$current_theme ?>.css"/>
     <link href="Styles/TestPages.css" rel="stylesheet" type="text/css"/>
     </head>

     <body>

    - <!--
    -<pre class="brush: c#">
    -/** test */
    - hello
    -</pre>
    -<h1>SyntaxHighlighter 2.0</h1>
    -<p><a href="http://code.google.com/p/syntaxhighlighter/">http://code.google.com/p/syntaxhighlighter/</a></p>
    --->
    +<script type="text/javascript" src="Scripts/shCore.js"></script>
    +<? foreach (\$brushes as \$brush => \$label) : ?>
    +<script type="text/javascript" src="Scripts/shBrush<?= \$brush ?>.js"></script>
    +<? endforeach; ?>
    +<script type="text/javascript">
    +//<!--
    +var syntaxHighlighterConfig = {};
    +//-->
    +</script>
    +
     <h2><?= \$title ?></h2>

     <div class="layout">

      <select onchange="setTheme(this)" size="1">
      <? foreach (\$themes as \$theme => \$label) : ?>
    @@ -166,16 +164,11 @@
      <div class="footer">
          Copyright 2004-2008 Alex Gorbatchev.<br/>
      </div>

     </div>

    -<script type="text/javascript" src="Scripts/shCore.js"></script>
    -<? foreach (\$brushes as \$brush => \$label) : ?>
    -<script type="text/javascript" src="Scripts/shBrush<?= \$brush ?>.js"></script>
    -<? endforeach; ?>

     <script type="text/javascript">
     //<!--
     function themeUrl(value)
     {
         return url("theme", value);
    @@ -202,20 +195,14 @@

     function setTheme(sender)
     {
         window.location = themeUrl(sender.options[sender.selectedIndex].value);
     }

    -if(window.isBloggerMode == true)
    -    SyntaxHighlighter.BloggerMode();

    -SyntaxHighlighter.ClipboardSwf = 'Scripts/clipboard.swf';
    +syntaxHighlighterConfig.clipboardSwf = 'Scripts/clipboard.swf';

    -window.onload = function()
    -{
    +
      SyntaxHighlighter.highlight();
    -}
     //-->
     </script>

     </body>
     </html>

# erlang

    update(File, In, Out) ->
        InFile  = File ++ In,
        OutFile = File ++ Out,
        case is_file(OutFile) of
            true ->
                case writeable(OutFile) of
                    true ->
                        outofdate(InFile, OutFile);
                    false ->
                        %% can't write so we can't update
                        false
                end;
            false ->
                %% doesn't exist
                true
        end.

# groovy

    import groovy.swing.SwingBuilder
    import static java.awt.BorderLayout.*
    import java.awt.event.*

    //  set up variables
    count = 0
    def textlabel
    def text = "Actions: "
    def update = { c ->
        text += c
        textlabel.text = text
    }

    // create the listener
    def closureMap = [
        mousePressed:     { update 'M' },
        keyPressed:       { update 'K' },
        focusLost:        { update 'F' },
        windowIconified:  { update 'W' }
    ]
    def interfaces = [WindowListener, KeyListener, MouseListener, FocusListener]
    def listener = ProxyGenerator.instantiateAggregate(closureMap, interfaces)

    // now the GUI
    def swing = new SwingBuilder()
    def frame = swing.frame(title:'Frame') {
        borderLayout()
        textlabel = label(text:text, constraints: NORTH)
        button = button(text:'Click Me', constraints: SOUTH)
    }
    frame.addWindowListener listener
    ['Key', 'Mouse', 'Focus'].each {
        button."add${it}Listener" listener
        textlabel."add${it}Listener" listener
    }
    frame.pack()
    frame.show()

# haxe

    class Test {
        static function main() {
            var people = [
                "Elizabeth" => "Programmer",
                "Joel" => "Designer"
            ];
            for (name in people.keys()) {
                var job = people[name];
                trace('$name is a $job');
            }
        }
    }

# java

    package tutorial;

    import com.opensymphony.xwork2.ActionSupport;

    public class HelloWorld extends ActionSupport {
      private String name;
      public String getName() {
      return name;
      }
      public void setName(String name) {
          this.name = name;
      }
      public String execute() {
          name = "Hello, " + name + "!";
          return SUCCESS;
      }
    }

# javafx

    import javafx.scene.input.MouseEvent;
    import javafx.scene.Scene;
    import javafx.scene.shape.Circle;
    import javafx.scene.transform.Scale;
    import javafx.stage.Stage;

    /**
     * @author Patrick Webster
     */
    var mouseX: Number;
    var mouseY: Number;
    var scale: Float = (-2.3 - 1.0) * -1.;
    var egg: Circle;

    Stage {
      title: "Easing Raw Egg"
      scene: Scene {
          height: 0x1AB  width: 0X20C
          content:
          egg = Circle {
              centerX: bind mouseX
              centerY: bind mouseY
              radius: 323.456e-02
              transforms: Scale {
                  // Egg eases to moving mouse cursor
                  pivotX: bind mouseX
                  pivotY: bind mouseY
                  x: bind scale * .02298E3
                  y: bind scale *  32.56789
              }

              onMouseMoved: function( me: MouseEvent ) {
                  updateMousePosition(me);
              }
              onMouseWheelMoved: function( we: MouseEvent ) {
                  updateMousePosition(we);
                  updateScale(we);
              }
          }
      }
    }

    function updateMousePosition(me : MouseEvent) : Void {
      mouseX = me.x;
      mouseY = me.y;
    }

    function updateScale(we: MouseEvent) : Float {
      var newScale = scale + (we.wheelRotation * -0.1);
      if (newScale < 1.0)
          return scale = 1.0000000e+00;
      return scale = newScale;
    }

# javascript

    /**
     * This is a JavaScript sample.
     */
    var matches = require('./matches');

    module.exports = {
      /**
       * Applies all regular expression to the code and stores all found
       * matches in the `this.matches` array.
       */
      parse: function(code, regexList, opts)
      {
        var result = [];

        regexList = regexList || [];

        for (var i = 0, l = regexList.length; i < l; i++)
          // BUG: length returns len+1 for array if methods added to prototype chain (oising@gmail.com)
          if (typeof regexList[i] === 'object')
            result = result.concat(matches.find(code, regexList[i]));

        result = matches.sort(result);
        result = matches.removeNested(result);
        result = matches.compact(result);

        return result;
      }
    };

# perl

    #!/usr/bin/perl

    use strict;
    use warnings;

    use LWP::Socket;
    use FCGI::ProcManager qw/ pm_manage pm_pre_dispatch pm_post_dispatch /;

    # Prepare content and headers
    my $content = join "", map { $_ } <DATA>;
    my $headers ="HTTP/1.1 200 OK\r\n"
                . "Server: FlaresunsFakeServer/2009-09-10\r\n"
                . "Content-Type: text/html\r\n"
                . "Content-Length: " . length($content). "\r\n"
                . "Connection: close\r\n\r\n";

    # Prepare and open socket
    my $sock = new LWP::Socket();
    $sock->bind('127.0.0.1', '8080');
    $sock->listen(10);

    # Create 5 childs
    pm_manage(n_processes => 5);

    while ( my $socket = $sock->accept(10) ) {
        pm_pre_dispatch();
        $socket->write($headers);
        $socket->write($content);
        $socket->shutdown();
        pm_post_dispatch();
    }

    $sock->shutdown();

    __DATA__
    <html>
    <head><title>Hi</title></head>
    <body>
        <h1>Hello from Habr!</h1>
    </body>
    </html>

# php

    <?php
    if (!defined('MEDIAWIKI'))
      exit(1);

    $wgExtensionFunctions[] = "wfSyntaxHighlighterExtension";

    $wgExtensionCredits['other'][] = array(
      'name' => 'SyntaxHighlighter',
      'author' => array('Alex Gorbatchev'),
      'version' => '1.0',
      'url' => 'http://alexgorbatchev.com/projects/syntaxhighlighter',
      'description' => 'Provides tight integration with SyntaxHighlighter.'
    );

    // Path to the SyntaxHighlighter scripts
    $wgSyntaxHighlighterScriptPath = "{$wgScriptPath}/extensions/SyntaxHighlighter/scripts";

    // Path to the SyntaxHighlighter styles
    $wgSyntaxHighlighterStylesPath = "{$wgScriptPath}/extensions/SyntaxHighlighter/styles";

    // Theme CSS file
    $wgSyntaxHighlighterTheme = "shThemeDefault.css";

    // Brushes to include on the page
    $wgSyntaxHighlighterBrushes = array(
      'shBrushBash.js',
      'shBrushCpp.js',
      'shBrushCSharp.js',
      'shBrushCss.js',
      'shBrushDelphi.js',
      'shBrushDiff.js',
      'shBrushGroovy.js',
      'shBrushJava.js',
      'shBrushJScript.js',
      'shBrushPhp.js',
      'shBrushPlain.js',
      'shBrushPython.js',
      'shBrushRuby.js',
      'shBrushScala.js',
      'shBrushSql.js',
      'shBrushVb.js',
      'shBrushXml.js'
    );

    $dir = dirname(__FILE__) . '/';

    function wfSyntaxHighlighterExtension()
    {
      global $wgOut, $wgScriptPath, $wgParser,
          $wgSyntaxHighlighterBrushes, $wgSyntaxHighlighterScriptPath,
          $wgSyntaxHighlighterStylesPath, $wgSyntaxHighlighterTheme;

      // Make shCore.js the very first script to be included (before all the brushes)
      array_unshift($wgSyntaxHighlighterBrushes, 'shCore.js');

      $home = $wgSyntaxHighlighterScriptPath;

      // Add all scripts to the header
      foreach ($wgSyntaxHighlighterBrushes as $script)
          $wgOut->addScript("<script type=\"text/javascript\" src=\"{$wgSyntaxHighlighterScriptPath}/$script\"></script>\n");

      // Add CSS links
      foreach (array('shCore.css', $wgSyntaxHighlighterTheme) as $css)
          $wgOut->addHeadItem($css, "<link type=\"text/css\" rel=\"stylesheet\" href=\"{$wgSyntaxHighlighterStylesPath}/$css\"/>\n");

      // Add initialization code
      $wgOut->addScript(
          "<script type=\"text/javascript\">".
              "var syntaxHighlighterConfig = { clipboardSwf: '{$wgSyntaxHighlighterScriptPath}/clipboard.swf' };".
              "SyntaxHighlighter.highlight();".
          "</script>\n"
          );

      // Finally, set up a MediaWiki hook to the <sh /> tag
      $wgParser->setHook("sh", "wfSyntaxHighlighterExtensionRender");

      return true;
    }

    function wfSyntaxHighlighterExtensionRender($input, $argv, $parser)
    {
      $args = "";

      while (list($key, $val) = each($argv))
          $args .= "$key: $val;";

      $input = htmlspecialchars($input);
      return "<pre class=\"$args\">\n$input\n</pre>";
    }

# plain

    This is just plain
    text brush... Maybe
    somebody will need
    it :)

# powershell

    $request = [System.Net.WebRequest]::Create("http://www.somelocation.com/testlink.aspx")
    $response = $request.GetResponse()
    $requestStream = $response.GetResponseStream()
    $readStream = new-object System.IO.StreamReader $requestStream
    new-variable db
    $db = $readStream.ReadToEnd()
    $readStream.Close()
    $response.Close()

# python

    #!/usr/bin/python
    """
    xml2html: Convert XML to HTML

    *** SUPERSEDED by pyslt ***

    Uses SAX (event-based parsing).

    ***LICENSE***
    """

    _ID = '$Id: xml2html-1.01-1.py,v 1.1.1.1 2000/01/15 14:37:46 ecoaccess Exp $'

    import sys, copy
    from xml.sax.drivers.drv_xmlproc_val import *

    class myParser(SAX_XPValParser):
        """XML parser."""

        psl = None

        def handle_doctype(self, rootname, pub_id, sys_id):
            self.dtd_handler.doctypeDecl(rootname, pub_id, sys_id, self.psl)

    class docHandler:
        """XML Document events handler."""

        def characters(self, ch, start, length):
            """Handle a character data event.
            The data are contained in the substring of ch
            starting at position start and of length length."""

            print ch[start:start+length],

        def endDocument(self):
            """Handle an event for the end of a document."""

            pass

        def endElement(self, name):
            """Handle an event for the end of an element."""

            print self.translation_table[name].end()

        def ignorableWhitespace(self, ch, start, length):
            """Handle an event for ignorable whitespace in element content.
            The data are contained in the substring of ch
            starting at position start and of length length."""

            pass

        def processingInstruction(self, target, data):
            """Handle a processing instruction event."""

            pass

        def setDocumentLocator(self, locator):
            """Receive an object for locating the origin of SAX document events.
            locator is an object of type Locator."""

            pass

        def startDocument(self):
            """Handle an event for the beginning of a document."""

            pass

        def startElement(self, name, atts):
            """Handle an event for the beginning of an element.
            atts is an object of type AttributeList."""

            print self.translation_table[name].start(atts),

    class dtdHandler:
        """Document Type Definition events handler."""

        def notationDecl(self, name, publicId, systemId):
            """Handle a notation declaration event."""

            pass

        def unparsedEntityDecl(self, name, publicId, systemId, ndata):
            """Handle an unparsed entity declaration event."""

            pass

        def doctypeDecl(self, rootname, pub_id, sys_id, psl=None):
            """Handle a Doctype Declaration event."""

            #print "Document type: %s" % rootname

            # Here is where I would need to load in the appropriate translation
            # table.

            if psl:
                x = {'kludge': {}}
                execfile(psl, globals(), locals())
                translation_table = x['kludge']
            else:
                if rootname == "Bylaws":
                    from org.ecoaccess.dtd.Bylaws import translation_table
                elif rootname == "Funspec":
                    from org.ecoaccess.dtd.Funspec import translation_table
                else:
                    translation_table = {}

            docHandler.translation_table = translation_table

    # --- Main prog

    if __name__ == '__main__':
        p=myParser()
        if len(sys.argv) > 2:
            p.psl = sys.argv[2]
        p.setDocumentHandler(docHandler())
        p.setDTDHandler(dtdHandler())
        p.parse(sys.argv[1])

# ruby

    class Post < ActiveRecord::Base
      DEFAULT_LIMIT = 15

      acts_as_taggable

      has_many                :comments, :dependent => :destroy
      has_many                :approved_comments, :class_name => 'Comment'

      before_validation       :generate_slug
      before_validation       :set_dates
      before_save             :apply_filter

      validates_presence_of   :title, :slug, :body

      validate                :validate_published_at_natural

      def validate_published_at_natural
        errors.add("published_at_natural", "Unable to parse time") unless published?
      end

      attr_accessor :minor_edit
      def minor_edit
        @minor_edit ||= "1"
      end

      def minor_edit?
        self.minor_edit == "1"
      end

      def published?
        published_at?
      end

      attr_accessor :published_at_natural
      def published_at_natural
        @published_at_natural ||= published_at.send_with_default(:strftime, 'now', "%Y-%m-%d %H:%M")
      end

      class << self
        def build_for_preview(params)
          post = Post.new(params)
          post.generate_slug
          post.set_dates
          post.apply_filter
          TagList.from(params[:tag_list]).each do |tag|
            post.tags << Tag.new(:name => tag)
          end
          post
        end

        def find_recent(options = {})
          tag = options.delete(:tag)
          options = {
            :order      => 'posts.published_at DESC',
            :conditions => ['published_at < ?', Time.zone.now],
            :limit      => DEFAULT_LIMIT
          }.merge(options)
          if tag
            find_tagged_with(tag, options)
          else
            find(:all, options)
          end
        end

        def find_by_permalink(year, month, day, slug, options = {})
          begin
            day = Time.parse([year, month, day].collect(&:to_i).join("-")).midnight
            post = find_all_by_slug(slug, options).detect do |post|
              [:year, :month, :day].all? {|time|
                post.published_at.send(time) == day.send(time)
              }
            end
          rescue ArgumentError # Invalid time
            post = nil
          end
          post || raise(ActiveRecord::RecordNotFound)
        end

        def find_all_grouped_by_month
          posts = find(
            :all,
            :order      => 'posts.published_at DESC',
            :conditions => ['published_at < ?', Time.now]
          )
          month = Struct.new(:date, :posts)
          posts.group_by(&:month).inject([]) {|a, v| a << month.new(v[0], v[1])}
        end
      end

      def destroy_with_undo
        transaction do
          self.destroy
          return DeletePostUndo.create_undo(self)
        end
      end

      def month
        published_at.beginning_of_month
      end

      def apply_filter
        self.body_html = EnkiFormatter.format_as_xhtml(self.body)
      end

      def set_dates
        self.edited_at = Time.now if self.edited_at.nil? || !minor_edit?
        self.published_at = Chronic.parse(self.published_at_natural)
      end

      def denormalize_comments_count!
        Post.update_all(["approved_comments_count = ?", self.approved_comments.count], ["id = ?", self.id])
      end

      def generate_slug
        self.slug = self.title.dup if self.slug.blank?
        self.slug.slugorize!
      end

      # TODO: Contribute this back to acts_as_taggable_on_steroids plugin
      def tag_list=(value)
        value = value.join(", ") if value.respond_to?(:join)
        super(value)
      end
    end

# sass

    $background                   : white !default;

    $line_alt1_background         : $background !default;
    $line_alt2_background         : $background !default;

    $line_highlighted_background  : #e0e0e0 !default;
    $line_highlighted_number      : black !default;

    $gutter_text                  : #afafaf !default;
    $gutter_border_color          : #6ce26c !default;
    $gutter_border                : 3px solid $gutter_border_color !default;

    $toolbar_collapsed_a          : #00f !default;
    $toolbar_collapsed_a_hover    : #f00 !default;
    $toolbar_collapsed_background : #fff !default;
    $toolbar_collapsed_border     : 1px solid $gutter_border_color !default;

    $toolbar_a                    : #fff !default;
    $toolbar_a_hover              : #000 !default;
    $toolbar_background           : $gutter_border_color !default;
    $toolbar_border               : none !default;

    $code_plain                   : black !default;
    $code_comments                : #008200 !default;
    $code_string                  : blue !default;
    $code_keyword                 : #006699 !default;
    $code_preprocessor            : gray !default;
    $code_variable                : #aa7700 !default;
    $code_value                   : #009900 !default;
    $code_functions               : #ff1493 !default;
    $code_constants               : #0066cc !default;
    $code_script                  : $code_keyword !default;
    $code_script_background       : none !default;
    $code_color1                  : gray !default;
    $code_color2                  : #ff1493 !default;
    $code_color3                  : red !default;

    $caption_color                : $code_plain !default;

    @mixin round_corners_custom($top, $right, $bottom, $left) {
      -moz-border-radius: $top $right $bottom $left !important;
      -webkit-border-radius: $top $right $bottom $left !important;
    }

    @mixin round_corners($radius) {
      @include round_corners_custom($radius, $radius, $radius, $radius);
    }

    .syntaxhighlighter {
      a,
      div,
      code,
      table,
      table td,
      table tr,
      table tbody,
      table thead,
      table caption,
      textarea {
        @include round_corners(0);

        background: none !important;
        border: 0 !important;
        bottom: auto !important;
        float: none !important;
        height: auto !important;
        left: auto !important;
        line-height: 1.1em !important;
        margin: 0 !important;
        outline: 0 !important;
        overflow: visible !important;
        padding: 0 !important;
        position: static !important;
        right: auto !important;
        text-align: left !important;
        top: auto !important;
        vertical-align: baseline !important;
        width: auto !important;
        box-sizing: content-box !important;
        font: {
          family: "Consolas", "Bitstream Vera Sans Mono", "Courier New", Courier, monospace !important;
          weight: normal !important;
          style: normal !important;
          size: 1em !important;
        }
        min: {
          // For IE8, FF & WebKit
          height: inherit !important;
          // For IE7
          height: auto !important;
        }
      }
    }

    .syntaxhighlighter {
      width: 100% !important;
      margin: 1em 0 1em 0 !important;

      position: relative !important;
      overflow: auto !important;
      font-size: 1em !important;

      &.source { overflow: hidden !important; }

      // set up bold and italic
      .bold { font-weight: bold !important; }
      .italic { font-style: italic !important; }

      .line { white-space: pre !important; }

      // main table and columns
      table {
        width: 100% !important;
        caption {
          text-align: left !important;
          padding: .5em 0 0.5em 1em !important;
        }

        td.code {
          width: 100% !important;

          .container {
            position: relative !important;

            textarea {
              box-sizing: border-box !important;
              position: absolute !important;
              left: 0 !important;
              top: 0 !important;
              width: 100% !important;
              height: 100% !important;
              border: none !important;
              background: white !important;
              padding-left: 1em !important;
              overflow: hidden !important;
              white-space: pre !important;
            }
          }
        }

        // middle spacing between line numbers and lines
        td.gutter .line {
          text-align: right !important;
          padding: 0 0.5em 0 1em !important;
        }

        td.code .line {
          padding: 0 1em !important;
        }
      }

      &.nogutter {
        td.code {
          .container textarea, .line { padding-left: 0em !important; }
        }
      }

      &.show { display: block !important; }

      // Adjust some properties when collapsed
      &.collapsed {
        table { display: none !important; }

        .toolbar {
          padding: 0.1em 0.8em 0em 0.8em !important;
          font-size: 1em !important;
          position: static !important;
          width: auto !important;
          height: auto !important;

          span {
            display: inline !important;
            margin-right: 1em !important;

            a {
              padding: 0 !important;
              display: none !important;
              &.expandSource { display: inline !important; }
            }
          }
        }
      }

      // Styles for the toolbar
      .toolbar {
        position: absolute !important;
        right: 1px !important;
        top: 1px !important;
        width: 11px !important;
        height: 11px !important;
        font-size: 10px !important;
        z-index: 10 !important;

        span.title { display: inline !important; }

        a {
          display: block !important;
          text-align: center !important;
          text-decoration: none !important;
          padding-top: 1px !important;

          &.expandSource { display: none !important; }
        }
      }

      &.ie {
        font-size: .9em !important;
        padding: 1px 0 1px 0 !important;

        .toolbar {
          line-height: 8px !important;
          a {
            padding-top: 0px !important;
          }
        }
      }

      // Print view.
      // Colors are based on the default theme without background.
      &.printing {
        .line.alt1 .content,
        .line.alt2 .content,
        .line.highlighted .number,
        .line.highlighted.alt1 .content,
        .line.highlighted.alt2 .content { background: none !important; }

        // Gutter line numbers
        .line {
          .number { color: #bbbbbb !important; }
          // Add border to the lines
          .content { color: black !important; }
        }

        // Toolbar when visible
        .toolbar { display: none !important; }
        a { text-decoration: none !important; }
        .plain, .plain a { color: black !important; }
        .comments, .comments a { color: #008200 !important; }
        .string, .string a { color: blue !important; }
        .keyword {
          color: #006699 !important;
          font-weight: bold !important;
        }
        .preprocessor { color: gray !important; }
        .variable { color: #aa7700 !important; }
        .value { color: #009900 !important; }
        .functions { color: #ff1493 !important; }
        .constants { color: #0066cc !important; }
        .script { font-weight: bold !important; }
        .color1, .color1 a { color: gray !important; }
        .color2, .color2 a { color: #ff1493 !important; }
        .color3, .color3 a { color: red !important; }
        .break, .break a { color: black !important; }
      }
    }

    // Interface elements.
    .syntaxhighlighter {
      background-color: $background !important;

      // Highlighed line number
      .line {
        &.alt1 { background-color: $line_alt1_background !important; }
        &.alt2 { background-color: $line_alt2_background !important; }

        // Highlighed line
        &.highlighted {
          &.alt1, &.alt2 { background-color: $line_highlighted_background !important; }
          &.number { color: $line_highlighted_number !important; }
        }
      }

      table {
        caption {
          color: $caption_color !important;
        }

        td.code {
          .container {
            textarea {
              background: $background;
              color: $code_plain;
            }
          }
        }
      }

      // Add border to the lines
      .gutter {
        color: $gutter_text !important;
        .line {
          border-right: $gutter_border !important;

          &.highlighted {
            background-color: $gutter_border_color !important;
            color: $background !important;
          }
        }
      }

      &.printing .line .content { border: none !important; }

      &.collapsed {
        overflow: visible !important;

        .toolbar {
          color: $toolbar_collapsed_a !important;
          background: $toolbar_collapsed_background !important;
          border: $toolbar_collapsed_border !important;

          a {
            color: $toolbar_collapsed_a !important;
            &:hover { color: $toolbar_collapsed_a_hover !important; }
          }
        }
      }

      .toolbar {
        color: $toolbar_a !important;
        background: $toolbar_background !important;
        border: $toolbar_border !important;
        a {
          color: $toolbar_a !important;
          &:hover { color: $toolbar_a_hover !important; }
        }
      }

      // Actual syntax highlighter colors.
      .plain, .plain a { color: $code_plain !important; }
      .comments, .comments a { color: $code_comments !important; }
      .string, .string a { color: $code_string !important; }
      .keyword { font-weight: bold !important; color: $code_keyword !important; }
      .preprocessor { color: $code_preprocessor !important; }
      .variable { color: $code_variable !important; }
      .value { color: $code_value !important; }
      .functions { color: $code_functions !important; }
      .constants { color: $code_constants !important; }
      .script {
        font-weight: bold !important;
        color: $code_script !important;
        background-color: $code_script_background !important;
      }
      .color1, .color1 a { color: $code_color1 !important; }
      .color2, .color2 a { color: $code_color2 !important; }
      .color3, .color3 a { color: $code_color3 !important; }
    }

# scala

    package examples

    /** Illustrate the use of pattern matching in Scala.
     *  Like patterns.scala, but uses extractors for representation independence
     */
    object extractorPatterns {

      /** We need an abstract base class for trees. Subclasses with
       *  the 'case' modifier can be used in pattern matching expressions
       *  to deconstruct trees.
       *
       *  Here, we replaced case classes of patterns.scala with objects
       *  that hide the actual implementation of Branch and Leaf. Note
       *  that the remaining code does not change. In this way, we
       *  can change the implementation later without affecting clients,
       *  which is called representation independence.
       */
      abstract class Tree

      object Branch {
        /* method to contruct branches @see extractorPatterns.tree1 */
        def apply(left: Tree, right: Tree): Tree = new BranchImpl(left, right)
        /* extractor method referenced in match expressions @see extractorPatterns.sumLeaves */
        def unapply(x:Tree): Option[(Tree,Tree)] = x match {
          case y:BranchImpl => Some(y.left, y.right)
          case _            => None
        }
        private class BranchImpl(val left:Tree, val right:Tree) extends Tree
      }
      object Leaf {
        /* method to contruct leaves @see tree1 */
        def apply(x:Int): Tree = new LeafImpl(x);
        /* extractor method referenced in match expressions @see extractorPatterns.sumLeaves */
        def unapply(x:Tree): Option[Int] = x match {
          case y:LeafImpl => Some(y.x)
          case _          => None
        }
        private class LeafImpl(val x: Int) extends Tree
      }

      /** Case classes have an implicit constructor methods which allows
       *  to create objects withouth the 'new' keyword. It saves some typing
       *  and makes code clearer.
       *
       *  Here, the task of the case class constructor is performed by the
       *  method Branch.apply - the singleton Branch is treated as if it
       *  were a function value. This trick works with any value that has
       *  an apply method.
       */
      val tree1 = Branch(Branch(Leaf(1), Leaf(2)), Branch(Leaf(3), Leaf(4)))

      /** Return the sum of numbers found in leaves.
       *  'match' is a generalization of 'switch' in C-like languages
       *
       *  Patterns consist of case class constructors (which can
       *  be nested), and lower case variables which are
       *  bound to the values with which the class has been constructed.
       *
       *  For extractors, it is not the name of a case class, but the name of
       *  the singleton object Branch which is used to refer to its extractor method
       *  Branch.unapply - the pattern is the 'reverse' of a method
       *  call, with the result being matched in the subpatterns. This works
       *  for any value that has an appropriate extractor method.
       */
      def sumLeaves(t: Tree): Int = t match {
        case Branch(l, r) => sumLeaves(l) + sumLeaves(r)
        case Leaf(x) => x
      }

      /** This illustrates the use of Option types. Since the
       *  method is not known in advance to find 'x', the
       *  return type is an Option. Options have two possible
       *  values, either 'Some' or 'None'. It is a type-safe
       *  way around 'null' values.
       */
      def find[A, B](it: Iterator[Pair[A, B]], x: A): Option[B] = {
        var result: Option[B] = None
        while (it.hasNext && result == None) {
          val Pair(x1, y) = it.next;
          if (x == x1) result = Some(y)
        }
        result
      }

      def printFinds[A](xs: List[Pair[A, String]], x: A) =
        find(xs.elements, x) match {
          case Some(y) => println(y)
          case None => println("no match")
        }

      def main(args: Array[String]) {
        println("sum of leafs=" + sumLeaves(tree1));
        printFinds(List(Pair(3, "three"), Pair(4, "four")), 4)
      }
    }

# sql

    -- Data model to support XML exchange with thecontent repository of
    -- the ArsDigita Community System

    -- Copyright (C) 1999-2000 ArsDigita Corporation
    -- Author: Karl Goldstein (karlg@arsdigita.com)

    -- $Id: content-xml.sql,v 1.3 2001/04/28 19:58:39 donb Exp $

    -- This is free software distributed under the terms of the GNU Public
    -- License.  Full text of the license is available from the GNU Project:
    -- http://www.fsf.org/copyleft/gpl.html

    -- A sequence for uniquely identifying uploaded XML documents until
    -- they are inserted into the repository

    create sequence cr_xml_doc_seq;

    -- create global temporary table cr_xml_docs (
    --     doc_id        integer primary key,
    --     doc           CLOB
    -- ) on commit delete rows;

    create table cr_xml_docs (
        doc_id        integer primary key,
        doc           text
    );

    comment on table cr_xml_docs is '
      A temporary table for holding uploaded XML documents for the
      duration of a transaction, until they can be inserted into
      the content repository.
    ';

# swift

    var dict = ["a": "Apple",                   // set up the Dictionary
                "b": "Banana",
                "c": "Cherry"]
    let bananaIndex = dict.indexForKey("b")!    // retrieve an index
    println(dict[bananaIndex])                  // subscript via DictionaryIndex<String, String>
    > (b, Banana)
    println(dict["c"])                          // subscript via String key
    > Optional("Cherry")

    let set: Set = ["Apple", "Banana", "Cherry"]  // set up the Set
    let start: Int = set.startIndex
    println(set[start])
    > Cherry

    println(set["Apple"])
    error: type 'Index' does not conform to protocol 'StringLiteralConvertible'

    /*
    Checked equality (true) on equal big sets in 0.923960983753204
    Checked equality (false) on different-size big sets in 2.98023223876953e-06
    Checked equality (false) on same-size unequal big sets in 0.908538997173309
    */

# tap

     1..4
     ok 1 - Input file opened
     not ok 2 - First line of the input valid
     ok 3 - Read the rest of the file
     not ok 4 - Summarized correctly # TODO Not written yet

# typescript

    /**
     * TypeScript lets you write JavaScript the way you really want to.
     * TypeScript is a typed superset of JavaScript that compiles to plain JavaScript.
     * Any browser. Any host. Any OS. Open Source.
     */
    class Animal {
        constructor(public name: string) { }
        move(meters: number) {
            alert(this.name + " moved " + meters + "m.");
        }
    }

    class Snake extends Animal {
        constructor(name: string) { super(name); }
        move() {
            alert("Slithering...");
            super.move(5);
        }
    }

    class Horse extends Animal {
        constructor(name: string) { super(name); }
        move() {
            alert("Galloping...");
            super.move(45);
        }
    }

    var sam = new Snake("Sammy the Python");
    var tom: Animal = new Horse("Tommy the Palomino");

    sam.move();
    tom.move(34);

# vb

    '
    ' DotNetNuke - http://www.dotnetnuke.com
    ' Copyright (c) 2002-2005
    ' by Perpetual Motion Interactive Systems Inc. ( http://www.perpetualmotion.ca )
    '
    ' Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
    ' documentation files (the "Software"), to deal in the Software without restriction, including without limitation
    ' the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and
    ' to permit persons to whom the Software is furnished to do so, subject to the following conditions:
    '
    ' The above copyright notice and this permission notice shall be included in all copies or substantial portions
    ' of the Software.
    '
    ' THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
    ' TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
    ' THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
    ' CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    ' DEALINGS IN THE SOFTWARE.
    '
    Imports System
    Imports System.Xml
    Imports System.Collections
    Imports System.Reflection
    Imports System.Diagnostics

    Imports DotNetNuke.Framework.Providers

    Namespace DotNetNuke.Common.Utilities

        ''' -----------------------------------------------------------------------------
        ''' <summary>
        ''' The Config class provides access to the web.config file
        ''' </summary>
        ''' <remarks>
        ''' </remarks>
        ''' <history>
        '''       [cnurse]    11/15/2005  documented
        ''' </history>
        ''' -----------------------------------------------------------------------------
        Public Class Config

    #Region "Shared Methods"

            Public Shared Function AddAppSetting(ByVal xmlDoc As XmlDocument, ByVal Key As String, ByVal Value As String) As XmlDocument

                Dim xmlElement As xmlElement

                ' retrieve the appSettings node
                Dim xmlAppSettings As xmlNode = xmlDoc.SelectSingleNode("//appSettings")

                If Not xmlAppSettings Is Nothing Then
                    ' get the node based on key
                    Dim xmlNode As xmlNode = xmlAppSettings.SelectSingleNode(("//add[@key='" + Key + "']"))

                    If Not xmlNode Is Nothing Then
                        ' update the existing element
                        xmlElement = CType(xmlNode, xmlElement)
                        xmlElement.SetAttribute("value", Value)
                    Else
                        ' create a new element
                        xmlElement = xmlDoc.CreateElement("add")
                        xmlElement.SetAttribute("key", Key)
                        xmlElement.SetAttribute("value", Value)
                        xmlAppSettings.AppendChild(xmlElement)
                    End If
                End If

                ' return the xml doc
                Return xmlDoc

            End Function

            ''' -----------------------------------------------------------------------------
            ''' <summary>
            ''' Gets the default connection String as specified in the provider.
            ''' </summary>
            ''' <returns>The connection String</returns>
            ''' <remarks></remarks>
            ''' <history>
            '''       [cnurse]    11/15/2005  created
            ''' </history>
            ''' -----------------------------------------------------------------------------
            Public Shared Function GetConnectionString() As String
                Dim _providerConfiguration As ProviderConfiguration = ProviderConfiguration.GetProviderConfiguration("data")

                ' Read the configuration specific information for this provider
                Dim objProvider As Provider = CType(_providerConfiguration.Providers(_providerConfiguration.DefaultProvider), Provider)

                Return GetConnectionString(objProvider.Attributes("connectionStringName"))
            End Function

            ''' -----------------------------------------------------------------------------
            ''' <summary>
            ''' Gets the specified connection String
            ''' </summary>
            ''' <param name="name">Name of Connection String to return</param>
            ''' <returns>The connection String</returns>
            ''' <remarks></remarks>
            ''' <history>
            '''       [cnurse]    11/15/2005  created
            ''' </history>
            ''' -----------------------------------------------------------------------------
            Public Shared Function GetConnectionString(ByVal name As String) As String

                Dim connectionString As String = ""

                If connectionString = "" Then
                    'check if connection string is specified in <appsettings> (ASP.NET 1.1 / DNN v3.x)
                    If name <> "" Then
                        connectionString = Config.GetSetting(name)
                    End If
                End If

                Return connectionString
            End Function

            Public Shared Function GetSetting(ByVal setting As String) As String
                Return System.Configuration.ConfigurationSettings.AppSettings(setting)
            End Function

            Public Shared Function GetSection(ByVal section As String) As Object
                Return System.Configuration.ConfigurationSettings.GetConfig(section)
            End Function

            Public Shared Function Load() As XmlDocument
                ' open the web.config file
                Dim xmlDoc As New XmlDocument
                xmlDoc.Load(Common.Globals.ApplicationMapPath & "\web.config")
                Return xmlDoc
            End Function

            Public Shared Function Load(ByVal filename As String) As XmlDocument
                ' open the config file
                Dim xmlDoc As New XmlDocument
                xmlDoc.Load(Common.Globals.ApplicationMapPath & "\" & filename)
                Return xmlDoc
            End Function

            Public Shared Function Save(ByVal xmlDoc As XmlDocument) As String
                Try
                    ' save the config file
                    Dim writer As New XmlTextWriter(Common.Globals.ApplicationMapPath & "\web.config", Nothing)
                    writer.Formatting = Formatting.Indented
                    xmlDoc.WriteTo(writer)
                    writer.Flush()
                    writer.Close()
                    Return ""
                Catch exc As Exception
                    ' the file may be read-only or the file permissions may not be set properly
                    Return exc.Message
                End Try

            End Function

            Public Shared Function Save(ByVal xmlDoc As XmlDocument, ByVal filename As String) As String
                Try
                    ' save the config file
                    Dim writer As New XmlTextWriter(Common.Globals.ApplicationMapPath & "\" & filename, Nothing)
                    writer.Formatting = Formatting.Indented
                    xmlDoc.WriteTo(writer)
                    writer.Flush()
                    writer.Close()
                    Return ""
                Catch exc As Exception
                    ' the file may be read-only or the file permissions may not be set properly
                    Return exc.Message
                End Try

            End Function

            Public Shared Function UpdateMachineKey(ByVal xmlConfig As XmlDocument) As XmlDocument

                Dim objSecurity As New PortalSecurity
                Dim validationKey As String = objSecurity.CreateKey(20)
                Dim decryptionKey As String = objSecurity.CreateKey(24)

                xmlConfig = AddAppSetting(xmlConfig, "MachineValidationKey", validationKey)
                xmlConfig = AddAppSetting(xmlConfig, "MachineDecryptionKey", decryptionKey)
                xmlConfig = AddAppSetting(xmlConfig, "InstallationDate", Date.Today.ToShortDateString)

                Return xmlConfig

            End Function

    #End Region

        End Class

    End Namespace

# xml

    <?xml version="1.0" encoding="utf-8" ?>

    <!-- comments -->
    <rootNode xmlns:namespace="http://www.w3.org/TR/html4/">
      <childNodes>
        <childNode attribute1 = "value"
                   namespace:attribute2='value'
                   attribute3=''/>
        <childNode />
        <childNode />
        <childNode />
        <childNode
          attr1="value"
          attr2="10"
          attr3="hello"
              >
          value
        </childNode>
        <namespace:childNode>
          <![CDATA[
                  this is some CDATA content
                  <!-- comments inside cdata -->
                  <b alert='false'>tags inside cdata</b>
              ]]>

          value = "plain string outside"
          hello = world
        </namespace:childNode>
      </childNodes>
    </rootNode>

    <!--
      Multiline comments <b>tag</b>
    -->