Ticket #52: percent-internal-macro.patch

Source/CobraTokenizer.cobra

@@ -94 +94 @@
             r'AMBIGUOUS_COMMENT     \/\#.*',
             r'SPACE                 [ \t]+',
 
+            r'MACRO_STR             @[A-Za-z][A-Za-z0-9_]*',
             r'OPEN_GENERIC          [A-Za-z_][A-Za-z0-9_]*<of[ \n\r\t]',
             r'OPEN_IF               if\(',
             r'OPEN_CALL             [A-Za-z_][A-Za-z0-9_]*\(',
@@ -240 +241 @@
         
     def makeSTRING_STOP_DOUBLE(definition as String) as TokenDef?
         return StringStopTokenDef('STRING_STOP_DOUBLE', definition[0])
-
+            
+    def makeMACRO_STR(definition as String) as TokenDef?
+        return StringNamedExprTokenDef('MACRO_STR', definition, definition[0]) 
+            
+            
     def afterStart is override
         base.afterStart
         # CC:
@@ -439 +444 @@
         tok.value = s[:-3]
         return tok
 
+    # subst "expr=[CobraCore.toTechString([expr])" back into source line
+    def onMACRO_STR(tok as IToken) as IToken?
+        .checkForMacro(tok)
+        return nil
+        
     def onID(tok as IToken) as IToken?
         tok = .keywordOrWhich(tok, 'ID')
         if tok.which<>'ID'
@@ -842 +852 @@
                 on 'warning', pass
                 else, .throwError('Unrecognized compiler directive "[name]".')
 
+    var _macroTable = { 
+        'debug' : r"'{0}=[CobraCore.toTechString({0})]'",
+        'dts'   : r"'{0}=[CobraCore.toTechString({0})]'",   # descriptive-tech-string
+        'toTS'  : r"'[CobraCore.toTechString({0})]'",       # to-TechString 
+    }
 
+    def checkForMacro(tok as IToken)
+        # breakout macro of form '@' name or '@' name '(' expr ')', 
+        #  expand and substitute back into parse stream
+        i = tok.text.indexOf('(')
+        if i<0 
+            name = tok.text[1:]
+            exprStr = ''
+        else
+            name = tok.text[1:i]        # '@|name|('
+            exprStr = tok.text[i+1:-1]  # 'name(|expr|)'
+        #print name, exprStr
+        if _macroTable.containsKey(name)
+            mac = _macroTable[name]
+            subst = String.format(mac, "[exprStr]") to !    #"'[exprStr]=\[CobraCore.toTechString([exprStr])]'"
+            #print subst
+            _pushString(subst)
+        else
+            .throwError('Unrecognized macro "[name]".')
+
+
     ##
     ## Deprecated
     ##
@@ -1007 +1042 @@
             assert x._match(r"]foo\\[foo]") is nil
         body
             return _matchBetween(input, c']', _quote, c'[' )
+            
+class StringNamedExprTokenDef
+    inherits StringTokenDef
+    """
+    Match name and expression of form '@name(expr)'
+    """
+    var _name as String
+    #var _exprStr as String=''
+    var _re as Regex
+    
+    def init(which as String, regex as String, firstCh as char)
+        base.init(which, firstCh)
+        _name = regex
+        _re = Regex(regex, RegexOptions.Compiled)
+        
+    get firstChars as List<of char> is override
+        return [_quote]
+
+    def _match(input as String) as String? is override
+        test
+            x = StringNamedExprTokenDef('A_FOO', r'@[f][a-z]*', c'@')
+            # normal:
+            assert x._match('aoeu') is nil
+            assert x._match(r"@foo(bar) ") == r"@foo(bar)"
+            # miss:
+            assert x._match(r"@goo(a+33)") == nil
+            # escaped:
+            assert x._match(r"@foo(wokka\n") == nil
+            assert x._match(r"@foo\(wx1)") == r'@foo'
+            assert x._match(r"@foo(wx1\)") == nil
+            assert x._match(r"@foo()") == r'@foo()'
+            assert x._match(r'@foo(1+(2+3)-a) no more' ) == r'@foo(1+(2+3)-a)'
+            assert x._match(r'@foo((1)-1()) no more' ) == r'@foo((1)-1())'
+            assert x._match("(@foo)") is nil
+            # not this token def:
+            assert x._match("(@gfoo)") is nil
+            
+            assert x._match(r"@foo(\)")is nil
+            assert x._match(r"@foo(foo(foo))asas") == r'@foo(foo(foo))'
+        body
+            #if not input.startsWith(_name)
+            #   return nil
+            if not input[0] == _quote # '@'
+                return nil
+            if not _reMatch(input)
+                return nil
+            sb = StringBuilder(_name)
+            # match from '(' to terminating ')' handling escapes and nested ()
+            #  could become matchEnclosed(input, c'(', c')' )
+            startch = c'('
+            stopch  = c')'
+            l = _name.length
+            if input[l] <> startch, return _name    # nil 
+            nestCount = 0
+            isEscaped = false
+            for i in l : input.length
+                c = input[i]
+                if c == startch and not isEscaped, nestCount += 1
+                if c == c'\n', return nil
+                sb.append(c)
+                if isEscaped
+                    isEscaped = false
+                    continue
+                if c == stopch
+                    nestCount -= 1
+                    if nestCount == 0
+                        #_exprStr= input[l+1:i-1]
+                        return sb.toString
+                if c == c'\\', isEscaped = true
+            return nil
+        
+    def _reMatch(input as String) as bool
+        reMatch = _re.match(input)
+        if not reMatch.success
+            return false
+        assert reMatch.index == 0
+        assert reMatch.value
+        _name = reMatch.value to !
+        return true

Source/Tokenizer.cobra

@@ -269 +269 @@
     get token from var
 
     get tokenizer from var
+    
+class SourceLineState
+   
+    var sourceLine as String?
+    var sourceLineIndex as int
+    var colNum as int
+    var charNum as int
+    var fileName as String?
 
+    def init(srcLine as String?, srcLnIdx as int, colNum as int, charNum as int, fileName as String?)
+        .sourceLine = srcLine
+        .sourceLineIndex = srcLnIdx
+        .colNum  = colNum
+        .charNum = charNum
+        .fileName = fileName
 
 class Tokenizer
     """
@@ -582 +596 @@
             _colNum = 1
             return true
 
+    var _sourceLineStack = Stack<of SourceLineState>() #is private
+    def _pushString(s as String)
+        """ 
+        Push string of source into parse stream at current point
+        """
+        #_sourceLine = _sourceLine.insert(0, s)
+        sli = SourceLineState(_sourceLine, _sourceLineIndex, _colNum, _charNum, _fileName)
+        _sourceLineStack.push(sli)
+        _sourceLine=s
+        _colNum=1
+        _charNum=1
+        _fileName='(Internally pushed String [s])'
+        
+    def _sourceLinePushActive as bool
+        return _sourceLineStack.count >0    
+
+    def _sourceLinePop
+        assert _sourceLineStack.count >0
+        sli = _sourceLineStack.pop
+        _sourceLine       = sli.sourceLine
+        _sourceLineIndex  = sli.sourceLineIndex
+        _colNum           = sli.colNum
+        _charNum          = sli.charNum
+        _fileName         = sli.fileName
+    
     var _narrowTokenDefs = true
     var _minNumTokenDefsToNarrow = 4
 
@@ -596 +635 @@
                 # eat up queue first
                 return _tokenQueue.dequeue
             if not _sourceLine or not _sourceLine.length
-                if not _obtainSource()
+                if _sourceLinePushActive()
+                    _sourceLinePop
+                else if not _obtainSource()
                     return nil
             try
                 assert _tokenDefs
@@ -670 +711 @@
             assert _tokenDefsByFirstChar
             assert _sourceLine.length
             if _tokenDefsByFirstChar.containsKey(_sourceLine[0])
-                # print 'Using short list for char: [_sourceLine[0]], [_sourceLine[0] to int]'
+                #print 'Using short list for char: [_sourceLine[0]], [_sourceLine[0] to int]'
                 return _tokenDefsByFirstChar[_sourceLine[0]]
         return _tokenDefs to !
 

Tests/200-misc/290-internal-macro.cobra

@@ +1 @@
+# test for built in macro %debug taking an expression  
+# expanding to 'expr=[CobraCore.toTechString(expr)]'
+
+# if user definitions supported could be done something like this
+#%subst @debug(a)   '{0}=[CobraCore.toTechString({0})]'
+# better name - todts = to-descriptive-tech-string
+#%subst @todts(a)   '{0}=[CobraCore.toTechString({0})]'
+#   these could be useful additions
+#%subst @CLCC       'Comp.Lang.CobraCore'
+#%subst @toTS       'Comp.Lang.CobraCore.toTechString'
+
+class MacroStr
+    var xy is shared
+
+    def main is shared
+        .xy='zz zz zzz zzzz z zzzzzzz'
+        a = 47
+        b = [1,2,3,4,5]
+        c={'a':'b', 'b':'c', 'c':'d'}
+        x=@['Haere','Mae']
+        
+        assert @debug(a) == r'a=47'
+        assert @debug(b) == r'b=List<of int>[1, 2, 3, 4, 5]'
+
+        s = @debug(x)
+        assert s == r"x=String[]['Haere', 'Mae']"
+
+        sx = .xx(@debug(c))
+        assert sx == r"xx:: c=Dictionary<of String, String>{'a': 'b', 'b': 'c', 'c': 'd'}"
+
+        sx = @debug(.xy)
+        assert sx == ".xy='zz zz zzz zzzz z zzzzzzz'"
+        
+        #hidden gotcha: string has to be "" delimited since macro defn is '' delimited
+        assert  "xxxx[@debug(a)]yyy" == "xxxxa=47yyy"
+        
+    def xx(s as String) as String is shared
+        return "xx:: [s]"   
+        
+        

Developer/IntermediateReleaseNotes.text

@@ -83 +83 @@
  
 * Added a new built-in doc tool accessible via "cobra -doc ...". The documentation is generated to local HTML files using your declarations, doc strings, contracts, etc.
 
+* Added additional tracing convenience - %debug(expr) generates String 'expr=[CobraCore.toTechString(expr)'
+ for use where want trace like info without using trace statement (hopscc)
+
 * Added support for declaring and raising events. When raising events, passing "this" is implied (e.g., not required) since that is the normal behavior for events. Also, if the events argument has a default constructor, it too can be omitted.
 
 * Add support for specifying unsigned integers as Hex literals