@harmoniclabs/monaco-editor 0.52.0

package/website/src/website/data/home-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

package/website/src/website/data/home-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)
+  }
+
+}

package/website/src/website/data/home-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)))))

package/website/src/website/data/home-samples/sample.scss.txt

@@ -0,0 +1,37 @@
+$baseFontSizeInPixels: 14;
+
+@function px2em ($font_size, $base_font_size: $baseFontSizeInPixels) {  
+  @return ($font_size / $base_font_size) + em; 
+}
+
+h1 {
+  font-size: px2em(36, $baseFontSizeInPixels);
+}
+h2  {
+  font-size: px2em(28, $baseFontSizeInPixels);
+}
+.class {
+  font-size: px2em(14, $baseFontSizeInPixels);
+}
+
+nav {
+  ul {
+    margin: 0;
+    padding: 0;
+    list-style: none;
+  }
+
+  li { display: inline-block; }
+
+  a {
+    display: block;
+    padding: 6px 12px;
+    text-decoration: none;
+  }
+  
+  @each $animal in puma, sea-slug, egret, salamander {
+    .#{$animal}-icon {
+      background-image: url('/images/#{$animal}.png');
+    }
+  }
+}

package/website/src/website/data/home-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<&-

package/website/src/website/data/home-samples/sample.sol.txt

@@ -0,0 +1,139 @@
+pragma solidity ^0.4.11;
+
+/// @title Voting with delegation.
+contract Ballot {
+    // This declares a new complex type which will
+    // be used for variables later.
+    // It will represent a single voter.
+    struct Voter {
+        uint weight; // weight is accumulated by delegation
+        bool voted;  // if true, that person already voted
+        address delegate; // person delegated to
+        uint vote;   // index of the voted proposal
+    }
+
+    // This is a type for a single proposal.
+    struct Proposal {
+        bytes32 name;   // short name (up to 32 bytes)
+        uint voteCount; // number of accumulated votes
+    }
+
+    address public chairperson;
+
+    // This declares a state variable that
+    // stores a `Voter` struct for each possible address.
+    mapping(address => Voter) public voters;
+
+    // A dynamically-sized array of `Proposal` structs.
+    Proposal[] public proposals;
+
+    /// Create a new ballot to choose one of `proposalNames`.
+    function Ballot(bytes32[] proposalNames) {
+        chairperson = msg.sender;
+        voters[chairperson].weight = 1;
+
+        // For each of the provided proposal names,
+        // create a new proposal object and add it
+        // to the end of the array.
+        for (uint i = 0; i < proposalNames.length; i++) {
+            // `Proposal({...})` creates a temporary
+            // Proposal object and `proposals.push(...)`
+            // appends it to the end of `proposals`.
+            proposals.push(Proposal({
+                name: proposalNames[i],
+                voteCount: 0
+            }));
+        }
+    }
+
+    // Give `voter` the right to vote on this ballot.
+    // May only be called by `chairperson`.
+    function giveRightToVote(address voter) {
+        // If the argument of `require` evaluates to `false`,
+        // it terminates and reverts all changes to
+        // the state and to Ether balances. It is often
+        // a good idea to use this if functions are
+        // called incorrectly. But watch out, this
+        // will currently also consume all provided gas
+        // (this is planned to change in the future).
+        require((msg.sender == chairperson) && !voters[voter].voted && (voters[voter].weight == 0));
+        voters[voter].weight = 1;
+    }
+
+    /// Delegate your vote to the voter `to`.
+    function delegate(address to) {
+        // assigns reference
+        Voter sender = voters[msg.sender];
+        require(!sender.voted);
+
+        // Self-delegation is not allowed.
+        require(to != msg.sender);
+
+        // Forward the delegation as long as
+        // `to` also delegated.
+        // In general, such loops are very dangerous,
+        // because if they run too long, they might
+        // need more gas than is available in a block.
+        // In this case, the delegation will not be executed,
+        // but in other situations, such loops might
+        // cause a contract to get "stuck" completely.
+        while (voters[to].delegate != address(0)) {
+            to = voters[to].delegate;
+
+            // We found a loop in the delegation, not allowed.
+            require(to != msg.sender);
+        }
+
+        // Since `sender` is a reference, this
+        // modifies `voters[msg.sender].voted`
+        sender.voted = true;
+        sender.delegate = to;
+        Voter delegate = voters[to];
+        if (delegate.voted) {
+            // If the delegate already voted,
+            // directly add to the number of votes
+            proposals[delegate.vote].voteCount += sender.weight;
+        } else {
+            // If the delegate did not vote yet,
+            // add to her weight.
+            delegate.weight += sender.weight;
+        }
+    }
+
+    /// Give your vote (including votes delegated to you)
+    /// to proposal `proposals[proposal].name`.
+    function vote(uint proposal) {
+        Voter sender = voters[msg.sender];
+        require(!sender.voted);
+        sender.voted = true;
+        sender.vote = proposal;
+
+        // If `proposal` is out of the range of the array,
+        // this will throw automatically and revert all
+        // changes.
+        proposals[proposal].voteCount += sender.weight;
+    }
+
+    /// @dev Computes the winning proposal taking all
+    /// previous votes into account.
+    function winningProposal() constant
+            returns (uint winningProposal)
+    {
+        uint winningVoteCount = 0;
+        for (uint p = 0; p < proposals.length; p++) {
+            if (proposals[p].voteCount > winningVoteCount) {
+                winningVoteCount = proposals[p].voteCount;
+                winningProposal = p;
+            }
+        }
+    }
+
+    // Calls winningProposal() function to get the index
+    // of the winner contained in the proposals array and then
+    // returns the name of the winner
+    function winnerName() constant
+            returns (bytes32 winnerName)
+    {
+        winnerName = proposals[winningProposal()].name;
+    }
+}

package/website/src/website/data/home-samples/sample.sparql.txt

@@ -0,0 +1,7 @@
+  SELECT ?x ?name
+  {
+    ?x  foaf:mbox <mailto:alice@example> .
+    ?x  foaf:knows ?a1 .
+    ?a1 foaf:knows ?a2 .
+    ?a2 foaf:name ?name .
+  }

package/website/src/website/data/home-samples/sample.sql.txt

@@ -0,0 +1,52 @@
+CREATE TABLE dbo.EmployeePhoto
+(
+    EmployeeId INT NOT NULL PRIMARY KEY,
+    Photo VARBINARY(MAX) FILESTREAM NULL,
+    MyRowGuidColumn UNIQUEIDENTIFIER NOT NULL ROWGUIDCOL
+                    UNIQUE DEFAULT NEWID()
+);
+
+GO
+
+/*
+text_of_comment
+/* nested comment */
+*/
+
+-- line comment
+
+CREATE NONCLUSTERED INDEX IX_WorkOrder_ProductID
+    ON Production.WorkOrder(ProductID)
+    WITH (FILLFACTOR = 80,
+        PAD_INDEX = ON,
+        DROP_EXISTING = ON);
+GO
+
+WHILE (SELECT AVG(ListPrice) FROM Production.Product) < $300
+BEGIN
+   UPDATE Production.Product
+      SET ListPrice = ListPrice * 2
+   SELECT MAX(ListPrice) FROM Production.Product
+   IF (SELECT MAX(ListPrice) FROM Production.Product) > $500
+      BREAK
+   ELSE
+      CONTINUE
+END
+PRINT 'Too much for the market to bear';
+
+MERGE INTO Sales.SalesReason AS [Target]
+USING (VALUES ('Recommendation','Other'), ('Review', 'Marketing'), ('Internet', 'Promotion'))
+       AS [Source] ([NewName], NewReasonType)
+ON [Target].[Name] = [Source].[NewName]
+WHEN MATCHED
+THEN UPDATE SET ReasonType = [Source].NewReasonType
+WHEN NOT MATCHED BY TARGET
+THEN INSERT ([Name], ReasonType) VALUES ([NewName], NewReasonType)
+OUTPUT $action INTO @SummaryOfChanges;
+
+SELECT ProductID, OrderQty, SUM(LineTotal) AS Total
+FROM Sales.SalesOrderDetail
+WHERE UnitPrice < $5.00
+GROUP BY ProductID, OrderQty
+ORDER BY ProductID, OrderQty
+OPTION (HASH GROUP, FAST 10);

package/website/src/website/data/home-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

package/website/src/website/data/home-samples/sample.swift.txt

@@ -0,0 +1,50 @@
+import Foundation
+
+protocol APIControllerProtocol {
+    func didReceiveAPIResults(results: NSArray)
+}
+
+class APIController {
+    var delegate: APIControllerProtocol
+
+    init(delegate: APIControllerProtocol) {
+        self.delegate = delegate
+    }
+
+    func get(path: String) {
+        let url = NSURL(string: path)
+        let session = NSURLSession.sharedSession()
+        let task = session.dataTaskWithURL(url!, completionHandler: {data, response, error -> Void in
+            println("Task completed")
+            if(error != nil) {
+                // If there is an error in the web request, print it to the console
+                println(error.localizedDescription)
+            }
+            var err: NSError?
+            if let jsonResult = NSJSONSerialization.JSONObjectWithData(data, options: NSJSONReadingOptions.MutableContainers, error: &err) as? NSDictionary {
+                if(err != nil) {
+                    // If there is an error parsing JSON, print it to the console
+                    println("JSON Error \(err!.localizedDescription)")
+                }
+                if let results: NSArray = jsonResult["results"] as? NSArray {
+                    self.delegate.didReceiveAPIResults(results)
+                }
+            }
+        })
+
+        // The task is just an object with all these properties set
+        // In order to actually make the web request, we need to "resume"
+        task.resume()
+    }
+
+    func searchItunesFor(searchTerm: String) {
+        // The iTunes API wants multiple terms separated by + symbols, so replace spaces with + signs
+        let itunesSearchTerm = searchTerm.stringByReplacingOccurrencesOfString(" ", withString: "+", options: NSStringCompareOptions.CaseInsensitiveSearch, range: nil)
+
+        // Now escape anything else that isn't URL-friendly
+        if let escapedSearchTerm = itunesSearchTerm.stringByAddingPercentEscapesUsingEncoding(NSUTF8StringEncoding) {
+            let urlPath = "https://itunes.apple.com/search?term=\(escapedSearchTerm)&media=music&entity=album"
+        }
+    }
+
+}

package/website/src/website/data/home-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

package/website/src/website/data/home-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
+}

package/website/src/website/data/home-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>