Properly parse compiler errors for fiddles and mark them in the editor.

experimental/webtry/webtry.go

 package main
 
 import (
         "bytes"
         "crypto/md5"
         "database/sql"
         "encoding/base64"
         "encoding/binary"
         "encoding/json"
         "flag"
         "fmt"
         htemplate "html/template"
         "image"
         _ "image/gif"
         _ "image/jpeg"
         "image/png"
         "io/ioutil"
         "math/rand"
         "net"
         "net/http"
         "os"
         "os/exec"
         "path/filepath"
         "regexp"
+        "strconv"
         "strings"
         "text/template"
         "time"
 )
 
 import (
         "github.com/fiorix/go-web/autogzip"
         _ "github.com/go-sql-driver/mysql"
         "github.com/golang/glog"
         _ "github.com/mattn/go-sqlite3"
@@ skipping 44 matching lines @@
 
         // imageLink is the regex that matches URLs paths that are direct links to PNGs.
         imageLink = regexp.MustCompile("^/i/([a-z0-9-]+.png)$")
 
         // tryInfoLink is the regex that matches URLs paths that are direct links to data about a single try.
         tryInfoLink = regexp.MustCompile("^/json/([a-f0-9]+)$")
 
         // workspaceLink is the regex that matches URLs paths for workspaces.
         workspaceLink = regexp.MustCompile("^/w/([a-z0-9-]+)$")
 
+        // errorRE is ther regex that matches compiler errors and extracts the line / column information.
+        errorRE = regexp.MustCompile("^.*.cpp:(\\d+):(\\d+):\\s*(.*)")
+
         // workspaceNameAdj is a list of adjectives for building workspace names.
         workspaceNameAdj = []string{
                 "autumn", "hidden", "bitter", "misty", "silent", "empty", "dry", "dark",
                 "summer", "icy", "delicate", "quiet", "white", "cool", "spring", "winter",
                 "patient", "twilight", "dawn", "crimson", "wispy", "weathered", "blue",
                 "billowing", "broken", "cold", "damp", "falling", "frosty", "green",
                 "long", "late", "lingering", "bold", "little", "morning", "muddy", "old",
                 "red", "rough", "still", "small", "sparkling", "throbbing", "shy",
                 "wandering", "withered", "wild", "black", "young", "holy", "solitary",
                 "fragrant", "aged", "snowy", "proud", "floral", "restless", "divine",
@@ skipping 299 matching lines @@
         return hash, err
 }
 
 // expandGyp produces the GYP file needed to build the code
 func expandGyp(hash string) error {
         return writeTemplate(fmt.Sprintf("../../../cache/%s.gyp", hash), gypTemplate, struct{ Hash string }{hash})
 }
 
 // response is serialized to JSON as a response to POSTs.
 type response struct {
-        Message string `json:"message"`
-        StdOut  string `json:"stdout"`
-        Img     string `json:"img"`
-        Hash    string `json:"hash"`
+        Message       string         `json:"message"`
+        CompileErrors []compileError `json:"compileErrors"`
+        Img           string         `json:"img"`
+        Hash          string         `json:"hash"`
 }
 
 // doCmd executes the given command line string; the command being
 // run is expected to not care what its current working directory is.
 // Returns the stdout and stderr.
 func doCmd(commandLine string) (string, error) {
         glog.Infof("Command: %q\n", commandLine)
         programAndArgs := strings.SplitN(commandLine, " ", 2)
         program := programAndArgs[0]
         args := []string{}
@@ skipping 18 matching lines @@
 }
 
 // reportTryError formats an HTTP error response in JSON and also logs the detailed error message.
 func reportTryError(w http.ResponseWriter, r *http.Request, err error, message, hash string) {
         m := response{
                 Message: message,
                 Hash:    hash,
         }
         glog.Errorf("%s\n%s", message, err)
         resp, err := json.Marshal(m)
+
         if err != nil {
                 http.Error(w, "Failed to serialize a response", 500)
                 return
+        }
+        w.Header().Set("Content-Type", "text/plain")
+        w.Write(resp)
+}
+
+func reportCompileError(w http.ResponseWriter, r *http.Request, compileErrors []compileError, hash string) {
+        m := response{
+                CompileErrors: compileErrors,
+                Hash:          hash,
+        }
+
+        resp, err := json.Marshal(m)
+
+        if err != nil {
+                http.Error(w, "Failed to serialize a response", 500)
+                return
         }
         w.Header().Set("Content-Type", "text/plain")
         w.Write(resp)
 }
 
 func writeToDatabase(hash string, code string, workspaceName string, source int, width, height int, gpu bool) {
         if db == nil {
                 return
         }
         if _, err := db.Exec("INSERT INTO webtry (code, hash, width, height, gpu, source_image_id) VALUES(?, ?, ?, ?, ?, ?)", code, hash, width, height, gpu, source); err != nil {
@@ skipping 324 matching lines @@
         w.Header().Set("Content-Type", "application/json")
         w.Write(resp)
 }
 
 func cleanCompileOutput(s, hash string) string {
         old := "../../../cache/src/" + hash + ".cpp:"
         glog.Infof("replacing %q\n", old)
         return strings.Replace(s, old, "usercode.cpp:", -1)
 }
 
+type compileError struct {
+        Line   int    `json:"line"`
+        Column int    `json:"column"`
+        Error  string `json:"error"`
+}
+
 // mainHandler handles the GET and POST of the main page.
 func mainHandler(w http.ResponseWriter, r *http.Request) {
         glog.Infof("Main Handler: %q\n", r.URL.Path)
         requestsCounter.Inc(1)
         if r.Method == "GET" {
                 code := DEFAULT_SAMPLE
                 source := 0
                 width := 256
                 height := 256
                 gpu := false
@@ skipping 55 matching lines @@
                         cmd += " --gpu"
                 }
                 if *useChroot {
                         cmd = "schroot -c webtry --directory=/ -- /skia_build/skia/experimental/webtry/" + cmd
                 }
                 if request.Source > 0 {
                         cmd += fmt.Sprintf(" --source image-%d.png", request.Source)
                 }
 
                 message, err := doCmd(cmd)
+
+                outputLines := strings.Split(message, "\n")
+                errorLines := []compileError{}
+                for _, line := range outputLines {
+                        match := errorRE.FindStringSubmatch(line)
+                        if len(match) > 0 {
+                                lineNumber, parseError := strconv.Atoi(match[1])
+                                if parseError != nil {
+                                        glog.Errorf("ERROR: Couldn't parse line number from %s\n", match[1])
+                                        continue
+                                }
+                                columnNumber, parseError := strconv.Atoi(match[2])
+                                if parseError != nil {
+                                        glog.Errorf("ERROR: Couldn't parse column number from %s\n", match[2])
+                                        continue
+                                }
+                                errorLines = append(errorLines,
+                                        compileError{
+                                                Line:   lineNumber,
+                                                Column: columnNumber,
+                                                Error:  match[3],
+                                        })
+                        }
+                }
+
                 if err != nil {
-                        reportTryError(w, r, err, "Failed to run the code:\n"+message, hash)
+                        if len(errorLines) > 0 {
+                                reportCompileError(w, r, errorLines, hash)
+                        } else {
+                                reportTryError(w, r, err, "Failed to run the code:\n"+message, hash)
+                        }
                         return
                 }
+
                 png, err := ioutil.ReadFile("../../../inout/" + hash + ".png")
                 if err != nil {
                         reportTryError(w, r, err, "Failed to open the generated PNG.", hash)
                         return
                 }
 
                 m := response{
                         Message: message,
                         Img:     base64.StdEncoding.EncodeToString([]byte(png)),
                         Hash:    hash,
@@ skipping 18 matching lines @@
         http.HandleFunc("/sources/", autogzip.HandleFunc(sourcesHandler))
 
         // Resources are served directly
         // TODO add support for caching/etags/gzip
         http.Handle("/res/", autogzip.Handle(http.FileServer(http.Dir("./"))))
 
         // TODO Break out /c/ as it's own handler.
         http.HandleFunc("/", autogzip.HandleFunc(mainHandler))
         glog.Fatal(http.ListenAndServe(*port, nil))
 }