code review 3699041: godoc: support for regular expression full text search

src/cmd/godoc/godoc.go

 // Copyright 2009 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
 package main
 
 import (
         "bytes"
         "flag"
         "fmt"
         "go/ast"
         "go/doc"
         "go/parser"
         "go/printer"
-        "go/scanner"
         "go/token"
         "http"
         "io"
         "io/ioutil"
         "log"
         "os"
         pathutil "path"
         "regexp"
         "runtime"
         "sort"
-        "strconv"
         "strings"
         "template"
         "time"
         "utf8"
 )
 
 
 // ----------------------------------------------------------------------------
 // Globals
 
@@ skipping 22 matching lines @@
         goroot      = flag.String("goroot", runtime.GOROOT(), "Go root directory")
         testDir     = flag.String("testdir", "", "Go root subdirectory - for testing only (faster startups)")
         path        = flag.String("path", "", "additional package directories (colon-separated)")
         filter      = flag.String("filter", "", "filter file containing permitted package directory paths")
         filterMin   = flag.Int("filter_minutes", 0, "filter file update interval in minutes; disabled if <= 0")
         filterDelay delayTime // actual filter update interval in minutes; usually filterDelay == filterMin, but filterDelay may back off exponentially
 
         // layout control
         tabwidth       = flag.Int("tabwidth", 4, "tab width")
         showTimestamps = flag.Bool("timestamps", true, "show timestamps with directory listings")
-        fulltextIndex  = flag.Bool("fulltext", false, "build full text index for search queries")
-        regexpQueries  = flag.Bool("regexp", false, "interpret queries as regular expressions for full text search")
+        fulltextIndex  = flag.Bool("fulltext", false, "build full text index for regular expression queries")
 
         // file system mapping
         fsMap      Mapping // user-defined mapping
         fsTree     RWValue // *Directory tree of packages, updated with each sync
         pathFilter RWValue // filter used when building fsMap directory trees
         fsModified RWValue // timestamp of last call to invalidateIndex
 
         // http handlers
         fileServer http.Handler // default file server
         cmdHandler httpHandler
@@ skipping 184 matching lines @@
                         // no user-defined mapping found; use default mapping
                         relpath = path[len(prefix):]
                 }
         }
         // Only if path is an invalid absolute path is relpath == ""
         // at this point. This should never happen since absolute paths
         // are only created via godoc for files that do exist. However,
         // it is ok to return ""; it will simply provide a link to the
         // top of the pkg or src directories.
         return relpath
-}
-
-
-// ----------------------------------------------------------------------------
-// HTML formatting support
-
-// aposescaper implements an io.Writer that escapes single quotes:
-// ' is written as \' . It is used to escape text such that it can
-// be used as the content of single-quoted string literals.
-type aposescaper struct {
-        w io.Writer
-}
-
-
-func (e *aposescaper) Write(p []byte) (n int, err os.Error) {
-        backslash := []byte{'\\'}
-        var i, m int
-        for j, b := range p {
-                if b == '\'' {
-                        m, err = e.w.Write(p[i:j])
-                        n += m
-                        if err != nil {
-                                return
-                        }
-                        _, err = e.w.Write(backslash)
-                        if err != nil {
-                                return
-                        }
-                        i = j
-                }
-        }
-        m, err = e.w.Write(p[i:])
-        n += m
-        return
-}
-
-
-// Styler implements a printer.Styler.
-type Styler struct {
-        linetags  bool
-        highlight string
-        objmap    map[*ast.Object]int
-        idcount   int
-}
-
-
-func newStyler(highlight string) *Styler {
-        return &Styler{true, highlight, make(map[*ast.Object]int), 0}
-}
-
-
-// identId returns a number >= 0 identifying the *ast.Object
-// denoted by name. If no object is denoted, the result is < 0.
-//
-// TODO(gri): Consider making this a mapping from popup info
-//            (for that name) to id, instead of *ast.Object
-//            to id. If a lot of the popup info is the same
-//            (e.g. type information), this will reduce the
-//            size of the html generated.
-func (s *Styler) identId(name *ast.Ident) int {
-        obj := name.Obj
-        if obj == nil || s.objmap == nil {
-                return -1
-        }
-        id, found := s.objmap[obj]
-        if !found {
-                // first occurence
-                id = s.idcount
-                s.objmap[obj] = id
-                s.idcount++
-        }
-        return id
-}
-
-
-// writeObjInfo writes the popup info corresponding to obj to w.
-// The text is HTML-escaped and does not contain single quotes.
-func writeObjInfo(w io.Writer, fset *token.FileSet, obj *ast.Object) {
-        // for now, show object kind and name; eventually
-        // do something more interesting (show declaration,
-        // for instance)
-        if obj.Kind != ast.Bad {
-                fmt.Fprintf(w, "%s ", obj.Kind)
-        }
-        template.HTMLEscape(w, []byte(obj.Name))
-        // show type if we know it
-        if obj.Type != nil && obj.Type.Expr != nil {
-                fmt.Fprint(w, " ")
-                writeNode(&aposescaper{w}, fset, obj.Type.Expr, true, &defaultStyler)
-        }
-}
-
-
-// idList returns a Javascript array (source) with identifier popup
-// information: The i'th array entry is a single-quoted string with
-// the popup information for an identifier x with s.identId(x) == i,
-// for 0 <= i < s.idcount.
-func (s *Styler) idList(fset *token.FileSet) []byte {
-        var buf bytes.Buffer
-        buf.WriteString("[\n")
-
-        if s.idcount > 0 {
-                // invert objmap: create an array [id]obj from map[obj]id
-                a := make([]*ast.Object, s.idcount)
-                for obj, id := range s.objmap {
-                        a[id] = obj
-                }
-
-                // for each id, print object info as single-quoted Javascript string
-                for id, obj := range a {
-                        printIndex := false // enable for debugging (but longer html)
-                        if printIndex {
-                                fmt.Fprintf(&buf, "/* %4d */ ", id)
-                        }
-                        fmt.Fprint(&buf, "'")
-                        writeObjInfo(&buf, fset, obj)
-                        fmt.Fprint(&buf, "',\n")
-                }
-        }
-
-        buf.WriteString("]\n")
-        return buf.Bytes()
-}
-
-
-// Use the defaultStyler when there is no specific styler.
-// The defaultStyler does not emit line tags since they may
-// interfere with tags emitted by templates.
-// TODO(gri): Should emit line tags at the beginning of a line;
-//            never in the middle of code.
-var defaultStyler Styler
-
-
-func (s *Styler) LineTag(line int) (text []byte, tag printer.HTMLTag) {
-        if s.linetags {
-                tag = printer.HTMLTag{fmt.Sprintf(`<a id="L%d">`, line), "</a>"}
-        }
-        return
-}
-
-
-func (s *Styler) Comment(c *ast.Comment, line []byte) (text []byte, tag printer.HTMLTag) {
-        text = line
-        // minimal syntax-coloring of comments for now - people will want more
-        // (don't do anything more until there's a button to turn it on/off)
-        tag = printer.HTMLTag{`<span class="comment">`, "</span>"}
-        return
-}
-
-
-func (s *Styler) BasicLit(x *ast.BasicLit) (text []byte, tag printer.HTMLTag) {
-        text = x.Value
-        return
-}
-
-
-func (s *Styler) Ident(name *ast.Ident) (text []byte, tag printer.HTMLTag) {
-        text = []byte(name.Name)
-        var str string
-        if id := s.identId(name); id >= 0 {
-                str = fmt.Sprintf(` id="%d"`, id)
-        }
-        if s.highlight == name.Name {
-                str += ` class="highlight"`
-        }
-        if str != "" {
-                tag = printer.HTMLTag{"<span" + str + ">", "</span>"}
-        }
-        return
-}
-
-
-func (s *Styler) Token(tok token.Token) (text []byte, tag printer.HTMLTag) {
-        text = []byte(tok.String())
-        return
 }
 
 
 // ----------------------------------------------------------------------------
 // Tab conversion
 
 var spaces = []byte("                ") // 16 spaces seems like a good number
 
 const (
         indenting = iota
@@ skipping 59 matching lines @@
                 _, err = p.output.Write(data[pos:])
         }
         return
 }
 
 
 // ----------------------------------------------------------------------------
 // Templates
 
 // Write an AST-node to w; optionally html-escaped.
-func writeNode(w io.Writer, fset *token.FileSet, node interface{}, html bool, styler printer.Styler) {
+func writeNode(w io.Writer, fset *token.FileSet, node interface{}, html bool) {
         mode := printer.TabIndent | printer.UseSpaces
         if html {
                 mode |= printer.GenHTML
         }
         // convert trailing tabs into spaces using a tconv filter
         // to ensure a good outcome in most browsers (there may still
         // be tabs in comments and strings, but converting those into
         // the right number of spaces is much harder)
-        (&printer.Config{mode, *tabwidth, styler}).Fprint(&tconv{output: w}, fset, node)
+        (&printer.Config{mode, *tabwidth, nil}).Fprint(&tconv{output: w}, fset, node)
 }
 
 
 // Write text to w; optionally html-escaped.
 func writeText(w io.Writer, text []byte, html bool) {
         if html {
                 template.HTMLEscape(w, text)
                 return
         }
         w.Write(text)
 }
 
 
 // Write anything to w; optionally html-escaped.
 func writeAny(w io.Writer, fset *token.FileSet, html bool, x interface{}) {
         switch v := x.(type) {
         case []byte:
                 writeText(w, v, html)
         case string:
                 writeText(w, []byte(v), html)
         case ast.Decl, ast.Expr, ast.Stmt, *ast.File:
-                writeNode(w, fset, x, html, &defaultStyler)
+                writeNode(w, fset, x, html)
         default:
                 if html {
                         var buf bytes.Buffer
                         fmt.Fprint(&buf, x)
                         writeText(w, buf.Bytes(), true)
                 } else {
                         fmt.Fprint(w, x)
                 }
         }
 }
@@ skipping 44 matching lines @@
         var buf bytes.Buffer
         writeAny(&buf, fileset(x), false, x[0])
         template.HTMLEscape(w, []byte(http.URLEscape(string(buf.Bytes()))))
 }
 
 
 // Template formatter for the various "url-xxx" formats excluding url-esc.
 func urlFmt(w io.Writer, format string, x ...interface{}) {
         var path string
         var line int
+        var low, high int // selection
 
         // determine path and position info, if any
         type positioner interface {
                 Pos() token.Pos
+                End() token.Pos
         }
         switch t := x[0].(type) {
         case string:
                 path = t
         case positioner:
-                pos := t.Pos()
-                if pos.IsValid() {
-                        pos := fileset(x).Position(pos)
+                fset := fileset(x)
+                if p := t.Pos(); p.IsValid() {
+                        pos := fset.Position(p)
                         path = pos.Filename
                         line = pos.Line
+                        low = pos.Offset
+                }
+                if p := t.End(); p.IsValid() {
+                        high = fset.Position(p).Offset
                 }
         default:
                 // we should never reach here, but be resilient
                 // and assume the position is invalid (empty path,
                 // and line 0)
                 log.Printf("INTERNAL ERROR: urlFmt(%s) without a string or positioner", format)
         }
 
         // map path
         relpath := relativePath(path)
 
         // convert to relative URLs so that they can also
         // be used as relative file names in .txt templates
         switch format {
         default:
                 // we should never reach here, but be resilient
                 // and assume the url-pkg format instead
                 log.Printf("INTERNAL ERROR: urlFmt(%s)", format)
                 fallthrough
         case "url-pkg":
                 // because of the irregular mapping under goroot
                 // we need to correct certain relative paths
                 if strings.HasPrefix(relpath, "src/pkg/") {
                         relpath = relpath[len("src/pkg/"):]
                 }
                 template.HTMLEscape(w, []byte(pkgHandler.pattern[1:]+relpath)) // remove trailing '/' for relative URL
         case "url-src":
                 template.HTMLEscape(w, []byte(relpath))
         case "url-pos":
+                template.HTMLEscape(w, []byte(relpath))
+                // selection ranges are of form "s=low:high"
+                if low < high {
+                        fmt.Fprintf(w, "?s=%d:%d", low, high)
+                        // if we have a selection, position the page
+                        // such that the selection is a bit below the top
+                        line -= 10
+                        if line < 1 {
+                                line = 1
+                        }
+                }
                 // line id's in html-printed source are of the
                 // form "L%d" where %d stands for the line number
-                template.HTMLEscape(w, []byte(relpath))
-                fmt.Fprintf(w, "#L%d", line)
+                if line > 0 {
+                        fmt.Fprintf(w, "#L%d", line)
+                }
         }
 }
 
 
 // The strings in infoKinds must be properly html-escaped.
 var infoKinds = [nKinds]string{
         PackageClause: "package&nbsp;clause",
         ImportDecl:    "import&nbsp;decl",
         ConstDecl:     "const&nbsp;decl",
         TypeDecl:      "type&nbsp;decl",
@@ skipping 26 matching lines @@
                         line = 0
                 }
         }
         fmt.Fprintf(w, "%d", line)
 }
 
 
 // Template formatter for "infoSnippet" format.
 func infoSnippetFmt(w io.Writer, format string, x ...interface{}) {
         info := x[0].(SpotInfo)
-        text := `<span class="alert">no snippet text available</span>`
+        text := []byte(`<span class="alert">no snippet text available</span>`)
         if info.IsIndex() {
                 index, _ := searchIndex.get()
                 // no escaping of snippet text needed;
                 // snippet text is escaped when generated
                 text = index.(*Index).Snippet(info.Lori()).Text
         }
-        fmt.Fprint(w, text)
+        w.Write(text)
 }
 
 
 // Template formatter for "padding" format.
 func paddingFmt(w io.Writer, format string, x ...interface{}) {
         for i := x[0].(int); i > 0; i-- {
                 fmt.Fprint(w, `<td width="25"></td>`)
         }
 }
 
@@ skipping 62 matching lines @@
 
 var (
         codewalkHTML,
         codewalkdirHTML,
         dirlistHTML,
         errorHTML,
         godocHTML,
         packageHTML,
         packageText,
         searchHTML,
-        searchText,
-        sourceHTML *template.Template
+        searchText *template.Template
 )
 
 func readTemplates() {
         // have to delay until after flags processing since paths depend on goroot
         codewalkHTML = readTemplate("codewalk.html")
         codewalkdirHTML = readTemplate("codewalkdir.html")
         dirlistHTML = readTemplate("dirlist.html")
         errorHTML = readTemplate("error.html")
         godocHTML = readTemplate("godoc.html")
         packageHTML = readTemplate("package.html")
         packageText = readTemplate("package.txt")
         searchHTML = readTemplate("search.html")
         searchText = readTemplate("search.txt")
-        sourceHTML = readTemplate("source.html")
 }
 
 
 // ----------------------------------------------------------------------------
 // Generic HTML wrapper
 
 func servePage(w http.ResponseWriter, title, subtitle, query string, content []byte) {
         d := struct {
                 Title    string
                 Subtitle string
@@ skipping 80 matching lines @@
 
 func applyTemplate(t *template.Template, name string, data interface{}) []byte {
         var buf bytes.Buffer
         if err := t.Execute(data, &buf); err != nil {
                 log.Printf("%s.Execute: %s", name, err)
         }
         return buf.Bytes()
 }
 
 
-func serveGoSource(w http.ResponseWriter, r *http.Request, abspath, relpath string) {
-        fset := token.NewFileSet()
-        file, err := parser.ParseFile(fset, abspath, nil, parser.ParseComments)
-        if err != nil {
-                log.Printf("parser.ParseFile: %s", err)
-                serveError(w, r, relpath, err)
-                return
-        }
-
-        // TODO(gri) enable once we are confident it works for all files
-        // augment AST with types; ignore errors (partial type information ok)
-        // typechecker.CheckFile(file, nil)
-
-        var buf bytes.Buffer
-        styler := newStyler(r.FormValue("h"))
-        writeNode(&buf, fset, file, true, styler)
-
-        type SourceInfo struct {
-                IdList []byte
-                Source []byte
-        }
-        info := &SourceInfo{styler.idList(fset), buf.Bytes()}
-
-        contents := applyTemplate(sourceHTML, "sourceHTML", info)
-        servePage(w, "Source file "+relpath, "", "", contents)
-}
-
-
 func redirect(w http.ResponseWriter, r *http.Request) (redirected bool) {
         if canonical := pathutil.Clean(r.URL.Path) + "/"; r.URL.Path != canonical {
                 http.Redirect(w, r, canonical, http.StatusMovedPermanently)
                 redirected = true
         }
         return
 }
 
 
 // TODO(gri): Should have a mapping from extension to handler, eventually.
@@ skipping 36 matching lines @@
                         // decoding error or control character - not a text file
                         return false
                 }
         }
 
         // likely a text file
         return true
 }
 
 
-// commentSelection computes the Selection for all Go comments in src.
-func commentSelection(src []byte) Selection {
-        var s scanner.Scanner
-        file := s.Init(token.NewFileSet(), "", src, nil, scanner.ScanComments+scanner.InsertSemis)
-        return func() (seg []int) {
-                for {
-                        pos, tok, lit := s.Scan()
-                        if tok == token.EOF {
-                                break
-                        }
-                        offs := file.Offset(pos)
-                        if tok == token.COMMENT {
-                                seg = []int{offs, offs + len(lit)}
-                                break
-                        }
-                }
-                return
-        }
-}
-
-
-func makeSelection(matches [][]int) Selection {
-        return func() (seg []int) {
-                if len(matches) > 0 {
-                        seg = matches[0]
-                        matches = matches[1:]
-                }
-                return
-        }
-}
-
-
-// regexpSelection computes the Selection for the regular expression expr in text.
-func regexpSelection(text []byte, expr string) Selection {
-        var matches [][]int
-        if rx, err := regexp.Compile(expr); err == nil {
-                matches = rx.FindAllIndex(text, -1)
-        }
-        return makeSelection(matches)
-}
-
-
-var selRx = regexp.MustCompile(`^([0-9]+):([0-9]+)`)
-
-func rangeSelection(str string, max int) Selection {
-        m := selRx.FindStringSubmatch(str)
-        if len(m) >= 2 {
-                from, _ := strconv.Atoi(m[1])
-                to, _ := strconv.Atoi(m[2])
-                if from < to {
-                        return makeSelection([][]int{[]int{from, to}})
-                }
-        }
-        return nil
-}
-
-
-// bit 0 (2^0 == 1): comments
-// bit 1 (2^1 == 2): highlights
-// bit 2 (2^2 == 4): selections
-//
-var startTags = []string{
-        /* 0 */ ``,
-        /* 1 */ `<span class ="comment">`,
-        /* 2 */ `<span class="highlight">`,
-        /* 3 */ `<span class="highlight-comment">`,
-        /* 4 */ `<span class="selection">`,
-        /* 5 */ `<span class="selection-comment">`,
-        /* 6 */ `<span class="selection-highlight">`,
-        /* 7 */ `<span class="selection-highlight-comment">`,
-}
-
-
-func formatText(text []byte, isGoFile bool, pattern, rangeStr string) []byte {
-        var buf bytes.Buffer
-        buf.WriteString("<pre>\n")
-
-        var comments, highlights, ranges Selection
-        if isGoFile {
-                comments = commentSelection(text)
-        }
-        if pattern != "" {
-                highlights = regexpSelection(text, pattern)
-        }
-        if rangeStr != "" {
-                ranges = rangeSelection(rangeStr, len(text))
-        }
-        if comments != nil || highlights != nil || ranges != nil {
-                FormatSelections(&buf, text, startTags, comments, highlights, ranges)
-        } else {
-                template.HTMLEscape(&buf, text)
-        }
-
-        buf.WriteString("</pre>\n")
-        return buf.Bytes()
-}
-
-
-func serveTextFile(w http.ResponseWriter, r *http.Request, abspath, relpath string) {
+func serveTextFile(w http.ResponseWriter, r *http.Request, abspath, relpath, title string) {
         src, err := ioutil.ReadFile(abspath)
         if err != nil {
                 log.Printf("ioutil.ReadFile: %s", err)
                 serveError(w, r, relpath, err)
                 return
         }
 
-        contents := formatText(src, pathutil.Ext(abspath) == ".go", r.FormValue("g"), r.FormValue("s"))
-        servePage(w, "Text file "+relpath, "", "", contents)
+        contents := FormatText(src, 1, pathutil.Ext(abspath) == ".go", r.FormValue("h"), rangeSelection(r.FormValue("s")))
+        servePage(w, title+" "+relpath, "", "", contents)
 }
 
 
 func serveDirectory(w http.ResponseWriter, r *http.Request, abspath, relpath string) {
         if redirect(w, r) {
                 return
         }
 
         list, err := ioutil.ReadDir(abspath)
         if err != nil {
@@ skipping 34 matching lines @@
                 if strings.HasSuffix(abspath, "/index.html") {
                         // We'll show index.html for the directory.
                         // Use the dir/ version as canonical instead of dir/index.html.
                         http.Redirect(w, r, r.URL.Path[0:len(r.URL.Path)-len("index.html")], http.StatusMovedPermanently)
                         return
                 }
                 serveHTMLDoc(w, r, abspath, relpath)
                 return
 
         case ".go":
-                if r.FormValue("g") != "" {
-                        serveTextFile(w, r, abspath, relpath)
-                        return
-                }
-                serveGoSource(w, r, abspath, relpath)
+                serveTextFile(w, r, abspath, relpath, "Source file")
                 return
         }
 
         dir, err := os.Lstat(abspath)
         if err != nil {
                 log.Print(err)
                 serveError(w, r, relpath, err)
                 return
         }
 
         if dir != nil && dir.IsDirectory() {
                 if redirect(w, r) {
                         return
                 }
                 if index := abspath + "/index.html"; isTextFile(index) {
                         serveHTMLDoc(w, r, index, relativePath(index))
                         return
                 }
                 serveDirectory(w, r, abspath, relpath)
                 return
         }
 
         if isTextFile(abspath) {
-                serveTextFile(w, r, abspath, relpath)
+                serveTextFile(w, r, abspath, relpath, "Text file")
                 return
         }
 
         fileServer.ServeHTTP(w, r)
 }
 
 
 // ----------------------------------------------------------------------------
 // Packages
 
@@ skipping 27 matching lines @@
         fsRoot  string // file system root to which the pattern is mapped
         isPkg   bool   // true if this handler serves real package documentation (as opposed to command documentation)
 }
 
 
 // getPageInfo returns the PageInfo for a package directory abspath. If the
 // parameter genAST is set, an AST containing only the package exports is
 // computed (PageInfo.PAst), otherwise package documentation (PageInfo.Doc)
 // is extracted from the AST. If there is no corresponding package in the
 // directory, PageInfo.PAst and PageInfo.PDoc are nil. If there are no sub-
-// directories, PageInfo.Dirs is nil. If a directory read error occured,
+// directories, PageInfo.Dirs is nil. If a directory read error occurred,
 // PageInfo.Err is set to the respective error but the error is not logged.
 //
 func (h *httpHandler) getPageInfo(abspath, relpath, pkgname string, mode PageInfoMode) PageInfo {
         // filter function to select the desired .go files
         filter := func(d *os.FileInfo) bool {
                 // If we are looking at cmd documentation, only accept
                 // the special fakePkgFile containing the documentation.
                 return isPkgFile(d) && (h.isPkg || d.Name == fakePkgFile)
         }
 
@@ skipping 178 matching lines @@
 
 type SearchResult struct {
         Query string
         Alert string // error or warning message
 
         // identifier matches
         Hit *LookupResult // identifier matches of Query
         Alt *AltWords     // alternative identifiers to look for
 
         // textual matches
-        Found    int         // number of textual occurences found
+        Found    int         // number of textual occurrences found
         Textual  []FileLines // textual matches of Query
-        Complete bool        // true if all textual occurences of Query are reported
+        Complete bool        // true if all textual occurrences of Query are reported
 }
 
 
 func lookup(query string) (result SearchResult) {
         result.Query = query
-
-        // if regexp queries are disabled, quote the query string:
-        // it will always compile and look like a literal
-        if !*regexpQueries {
-                query = regexp.QuoteMeta(query)
-        }
 
         // determine identifier lookup string and full text regexp
         lookupStr := ""
         lookupRx, err := regexp.Compile(query)
         if err != nil {
                 result.Alert = "Error in query regular expression: " + err.String()
                 return
         }
         if prefix, complete := lookupRx.LiteralPrefix(); complete {
                 // otherwise we lookup "" (with no result) because
@@ skipping 121 matching lines @@
                         log.Printf("after  GC: bytes = %d footprint = %d", runtime.MemStats.HeapAlloc, runtime.MemStats.Sys)
                 }
                 var delay int64 = 60 * 1e9 // by default, try every 60s
                 if *testDir != "" {
                         // in test mode, try once a second for fast startup
                         delay = 1 * 1e9
                 }
                 time.Sleep(delay)
         }
 }