case consistency part 8

compiler/c2nim/c2nim.nim

@@ -40,7 +40,7 @@ Options:
 
 proc main(infile, outfile: string, options: PParserOptions) =
   var start = getTime()
-  var stream = LLStreamOpen(infile, fmRead)
+  var stream = llStreamOpen(infile, fmRead)
   if stream == nil: rawMessage(errCannotOpenFile, infile)
   var p: TParser
   openParser(p, infile, stream, options)

compiler/c2nim/clex.nim

@@ -103,7 +103,7 @@ type
     inDirective: bool
   
 proc getTok*(L: var TLexer, tok: var TToken)
-proc PrintTok*(tok: TToken)
+proc printTok*(tok: TToken)
 proc `$`*(tok: TToken): string
 # implementation
 
@@ -138,7 +138,7 @@ proc lexMessagePos(L: var TLexer, msg: TMsgKind, pos: int, arg = "") =
   var info = newLineInfo(L.fileIdx, L.linenumber, pos - L.lineStart)
   msgs.GlobalError(info, msg, arg)
 
-proc TokKindToStr*(k: TTokKind): string =
+proc tokKindToStr*(k: TTokKind): string =
   case k
   of pxEof: result = "[EOF]"
   of pxInvalid: result = "[invalid]"
@@ -211,9 +211,9 @@ proc `$`(tok: TToken): string =
   of pxSymbol, pxInvalid, pxStarComment, pxLineComment, pxStrLit: result = tok.s
   of pxIntLit, pxInt64Lit: result = $tok.iNumber
   of pxFloatLit: result = $tok.fNumber
-  else: result = TokKindToStr(tok.xkind)
+  else: result = tokKindToStr(tok.xkind)
   
-proc PrintTok(tok: TToken) = 
+proc printTok(tok: TToken) = 
   writeln(stdout, $tok)
   
 proc matchUnderscoreChars(L: var TLexer, tok: var TToken, chars: TCharSet) = 
@@ -223,12 +223,12 @@ proc matchUnderscoreChars(L: var TLexer, tok: var TToken, chars: TCharSet) =
   while true: 
     if buf[pos] in chars: 
       add(tok.s, buf[pos])
-      Inc(pos)
+      inc(pos)
     else: 
       break 
     if buf[pos] == '_': 
       add(tok.s, '_')
-      Inc(pos)
+      inc(pos)
   L.bufPos = pos
 
 proc isFloatLiteral(s: string): bool = 
@@ -239,7 +239,7 @@ proc isFloatLiteral(s: string): bool =
 proc getNumber2(L: var TLexer, tok: var TToken) = 
   var pos = L.bufpos + 2 # skip 0b
   tok.base = base2
-  var xi: biggestInt = 0
+  var xi: BiggestInt = 0
   var bits = 0
   while true: 
     case L.buf[pos]
@@ -264,7 +264,7 @@ proc getNumber2(L: var TLexer, tok: var TToken) =
 proc getNumber8(L: var TLexer, tok: var TToken) = 
   var pos = L.bufpos + 1 # skip 0
   tok.base = base8
-  var xi: biggestInt = 0
+  var xi: BiggestInt = 0
   var bits = 0
   while true: 
     case L.buf[pos]
@@ -289,7 +289,7 @@ proc getNumber8(L: var TLexer, tok: var TToken) =
 proc getNumber16(L: var TLexer, tok: var TToken) = 
   var pos = L.bufpos + 2          # skip 0x
   tok.base = base16
-  var xi: biggestInt = 0
+  var xi: BiggestInt = 0
   var bits = 0
   while true: 
     case L.buf[pos]
@@ -327,7 +327,7 @@ proc getNumber(L: var TLexer, tok: var TToken) =
       tok.fnumber = parseFloat(tok.s)
       tok.xkind = pxFloatLit
     else: 
-      tok.iNumber = ParseInt(tok.s)
+      tok.iNumber = parseInt(tok.s)
       if (tok.iNumber < low(int32)) or (tok.iNumber > high(int32)): 
         tok.xkind = pxInt64Lit
       else: 
@@ -339,10 +339,10 @@ proc getNumber(L: var TLexer, tok: var TToken) =
   # ignore type suffix:
   while L.buf[L.bufpos] in {'A'..'Z', 'a'..'z'}: inc(L.bufpos)
   
-proc HandleCRLF(L: var TLexer, pos: int): int = 
+proc handleCRLF(L: var TLexer, pos: int): int = 
   case L.buf[pos]
-  of CR: result = nimlexbase.HandleCR(L, pos)
-  of LF: result = nimlexbase.HandleLF(L, pos)
+  of CR: result = nimlexbase.handleCR(L, pos)
+  of LF: result = nimlexbase.handleLF(L, pos)
   else: result = pos
   
 proc escape(L: var TLexer, tok: var TToken, allowEmpty=false) = 
@@ -405,7 +405,7 @@ proc getString(L: var TLexer, tok: var TToken) =
   while true: 
     case buf[pos]
     of '\"': 
-      Inc(pos)
+      inc(pos)
       break
     of CR: 
       pos = nimlexbase.HandleCR(L, pos)
@@ -427,7 +427,7 @@ proc getString(L: var TLexer, tok: var TToken) =
       pos = L.bufpos
     else: 
       add(tok.s, buf[pos])
-      Inc(pos)
+      inc(pos)
   L.bufpos = pos
   tok.xkind = pxStrLit
 
@@ -438,7 +438,7 @@ proc getSymbol(L: var TLexer, tok: var TToken) =
     var c = buf[pos]
     if c notin SymChars: break
     add(tok.s, c)
-    Inc(pos)
+    inc(pos)
   L.bufpos = pos
   tok.xkind = pxSymbol
 
@@ -475,7 +475,7 @@ proc scanStarComment(L: var TLexer, tok: var TToken) =
   while true: 
     case buf[pos]
     of CR, LF: 
-      pos = HandleCRLF(L, pos)
+      pos = handleCRLF(L, pos)
       buf = L.buf
       add(tok.s, "\n#")
       # skip annoying stars as line prefix: (eg.
@@ -511,12 +511,12 @@ proc skip(L: var TLexer, tok: var TToken) =
       if L.inDirective:
         while buf[pos] in {' ', '\t'}: inc(pos)
         if buf[pos] in {CR, LF}:
-          pos = HandleCRLF(L, pos)
+          pos = handleCRLF(L, pos)
           buf = L.buf
     of ' ', Tabulator: 
-      Inc(pos)                # newline is special:
+      inc(pos)                # newline is special:
     of CR, LF: 
-      pos = HandleCRLF(L, pos)
+      pos = handleCRLF(L, pos)
       buf = L.buf
       if L.inDirective:
         tok.xkind = pxNewLine
@@ -565,7 +565,7 @@ proc getTok(L: var TLexer, tok: var TToken) =
     case c
     of ';': 
       tok.xkind = pxSemicolon
-      Inc(L.bufpos)
+      inc(L.bufpos)
     of '/': 
       if L.buf[L.bufpos + 1] == '/': 
         scanLineComment(L, tok)
@@ -580,9 +580,9 @@ proc getTok(L: var TLexer, tok: var TToken) =
         inc(L.bufpos)
     of ',': 
       tok.xkind = pxComma
-      Inc(L.bufpos)
+      inc(L.bufpos)
     of '(': 
-      Inc(L.bufpos)
+      inc(L.bufpos)
       tok.xkind = pxParLe
     of '*': 
       inc(L.bufpos)
@@ -592,13 +592,13 @@ proc getTok(L: var TLexer, tok: var TToken) =
       else:
         tok.xkind = pxStar
     of ')': 
-      Inc(L.bufpos)
+      inc(L.bufpos)
       tok.xkind = pxParRi
     of '[': 
-      Inc(L.bufpos)
+      inc(L.bufpos)
       tok.xkind = pxBracketLe
     of ']': 
-      Inc(L.bufpos)
+      inc(L.bufpos)
       tok.xkind = pxBracketRi
     of '.': 
       inc(L.bufpos)
@@ -608,10 +608,10 @@ proc getTok(L: var TLexer, tok: var TToken) =
       else: 
         tok.xkind = pxDot
     of '{': 
-      Inc(L.bufpos)
+      inc(L.bufpos)
       tok.xkind = pxCurlyLe
     of '}': 
-      Inc(L.bufpos)
+      inc(L.bufpos)
       tok.xkind = pxCurlyRi
     of '+': 
       inc(L.bufpos)
@@ -752,4 +752,4 @@ proc getTok(L: var TLexer, tok: var TToken) =
       tok.s = $c
       tok.xkind = pxInvalid
       lexMessage(L, errInvalidToken, c & " (\\" & $(ord(c)) & ')')
-      Inc(L.bufpos)
+      inc(L.bufpos)

compiler/c2nim/cparse.nim

@@ -93,16 +93,16 @@ proc setOption*(parserOptions: PParserOptions, key: string, val=""): bool =
   of "class": parserOptions.classes[val] = "true"
   else: result = false
 
-proc ParseUnit*(p: var TParser): PNode
+proc parseUnit*(p: var TParser): PNode
 proc openParser*(p: var TParser, filename: string, inputStream: PLLStream,
                  options = newParserOptions())
 proc closeParser*(p: var TParser)
 
 # implementation
 
-proc OpenParser(p: var TParser, filename: string, 
+proc openParser(p: var TParser, filename: string, 
                 inputStream: PLLStream, options = newParserOptions()) = 
-  OpenLexer(p.lex, filename, inputStream)
+  openLexer(p.lex, filename, inputStream)
   p.options = options
   p.backtrack = @[]
   new(p.tok)
@@ -111,7 +111,7 @@ proc parMessage(p: TParser, msg: TMsgKind, arg = "") =
   #assert false
   lexMessage(p.lex, msg, arg)
 
-proc CloseParser(p: var TParser) = CloseLexer(p.lex)
+proc closeParser(p: var TParser) = closeLexer(p.lex)
 proc saveContext(p: var TParser) = p.backtrack.add(p.tok)
 proc closeContext(p: var TParser) = discard p.backtrack.pop()
 proc backtrackContext(p: var TParser) = p.tok = p.backtrack.pop()
@@ -145,7 +145,7 @@ proc findMacro(p: TParser): int =
 
 proc rawEat(p: var TParser, xkind: TTokKind) = 
   if p.tok.xkind == xkind: rawGetTok(p)
-  else: parMessage(p, errTokenExpected, TokKindToStr(xkind))
+  else: parMessage(p, errTokenExpected, tokKindToStr(xkind))
 
 proc parseMacroArguments(p: var TParser): seq[seq[ref TToken]] = 
   result = @[]
@@ -228,7 +228,7 @@ proc skipComAux(p: var TParser, n: PNode) =
   getTok(p)
 
 proc skipCom(p: var TParser, n: PNode) = 
-  while p.tok.xkind in {pxLineComment, pxStarComment}: skipcomAux(p, n)
+  while p.tok.xkind in {pxLineComment, pxStarComment}: skipComAux(p, n)
 
 proc skipStarCom(p: var TParser, n: PNode) = 
   while p.tok.xkind == pxStarComment: skipComAux(p, n)
@@ -242,11 +242,11 @@ proc expectIdent(p: TParser) =
   
 proc eat(p: var TParser, xkind: TTokKind, n: PNode) = 
   if p.tok.xkind == xkind: getTok(p, n)
-  else: parMessage(p, errTokenExpected, TokKindToStr(xkind))
+  else: parMessage(p, errTokenExpected, tokKindToStr(xkind))
   
 proc eat(p: var TParser, xkind: TTokKind) = 
   if p.tok.xkind == xkind: getTok(p)
-  else: parMessage(p, errTokenExpected, TokKindToStr(xkind))
+  else: parMessage(p, errTokenExpected, tokKindToStr(xkind))
   
 proc eat(p: var TParser, tok: string, n: PNode) = 
   if p.tok.s == tok: getTok(p, n)
@@ -605,7 +605,7 @@ proc addPragmas(father, pragmas: PNode) =
 proc addReturnType(params, rettyp: PNode) =
   if rettyp == nil: addSon(params, ast.emptyNode)
   elif rettyp.kind != nkNilLit: addSon(params, rettyp)
-  else: addson(params, ast.emptyNode)
+  else: addSon(params, ast.emptyNode)
 
 proc parseFormalParams(p: var TParser, params, pragmas: PNode)
 
@@ -690,8 +690,8 @@ proc parseStructBody(p: var TParser, isUnion: bool,
 proc structPragmas(p: TParser, name: PNode, origName: string): PNode = 
   assert name.kind == nkIdent
   result = newNodeP(nkPragmaExpr, p)
-  addson(result, exportSym(p, name, origName))
-  var pragmas = newNodep(nkPragma, p)
+  addSon(result, exportSym(p, name, origName))
+  var pragmas = newNodeP(nkPragma, p)
   addSon(pragmas, newIdentNodeP("pure", p), newIdentNodeP("final", p))
   if p.options.header.len > 0:
     addSon(pragmas, newIdentStrLitPair("importc", origName, p),
@@ -700,8 +700,8 @@ proc structPragmas(p: TParser, name: PNode, origName: string): PNode =
 
 proc enumPragmas(p: TParser, name: PNode): PNode =
   result = newNodeP(nkPragmaExpr, p)
-  addson(result, name)
-  var pragmas = newNodep(nkPragma, p)
+  addSon(result, name)
+  var pragmas = newNodeP(nkPragma, p)
   var e = newNodeP(nkExprColonExpr, p)
   # HACK: sizeof(cint) should be constructed as AST
   addSon(e, newIdentNodeP("size", p), newIdentNodeP("sizeof(cint)", p))
@@ -1045,7 +1045,7 @@ proc declaration(p: var TParser): PNode =
     of pxSemicolon: 
       getTok(p)
       addSon(result, ast.emptyNode) # nobody
-      if p.scopeCounter == 0: DoImport(origName, pragmas, p)
+      if p.scopeCounter == 0: doImport(origName, pragmas, p)
     of pxCurlyLe:
       addSon(result, compoundStatement(p))
     else:
@@ -1264,7 +1264,7 @@ proc additiveExpression(p: var TParser): PNode =
 proc incdec(p: var TParser, opr: string): PNode = 
   result = newNodeP(nkCall, p)
   addSon(result, newIdentNodeP(opr, p))
-  gettok(p, result)
+  getTok(p, result)
   addSon(result, unaryExpression(p))
 
 proc unaryOp(p: var TParser, kind: TNodeKind): PNode = 
@@ -1275,7 +1275,7 @@ proc unaryOp(p: var TParser, kind: TNodeKind): PNode =
 proc prefixCall(p: var TParser, opr: string): PNode = 
   result = newNodeP(nkPrefix, p)
   addSon(result, newIdentNodeP(opr, p))
-  gettok(p, result)
+  getTok(p, result)
   addSon(result, castExpression(p))
 
 proc postfixExpression(p: var TParser): PNode = 
@@ -1313,13 +1313,13 @@ proc postfixExpression(p: var TParser): PNode =
       var a = result
       result = newNodeP(nkCall, p)
       addSon(result, newIdentNodeP("inc", p))
-      gettok(p, result)
+      getTok(p, result)
       addSon(result, a)
     of pxMinusMinus:
       var a = result
       result = newNodeP(nkCall, p)
       addSon(result, newIdentNodeP("dec", p))
-      gettok(p, result)
+      getTok(p, result)
       addSon(result, a)
     of pxLt:
       if isTemplateAngleBracket(p):
@@ -1406,8 +1406,8 @@ proc assignmentExpression(p: var TParser): PNode =
     var b = assignmentExpression(p)
     result = newNodeP(nkAsgn, p)
     addSon(result, a, b)
-  of pxPlusAsgn: result = incDec(p, "inc", a)    
-  of pxMinusAsgn: result = incDec(p, "dec", a)
+  of pxPlusAsgn: result = incdec(p, "inc", a)    
+  of pxMinusAsgn: result = incdec(p, "dec", a)
   of pxStarAsgn: result = asgnExpr(p, "*", a)
   of pxSlashAsgn: result = asgnExpr(p, "/", a)
   of pxModAsgn: result = asgnExpr(p, "mod", a)
@@ -1433,7 +1433,7 @@ proc relationalExpression(p: var TParser): PNode =
   result = shiftExpression(p)
   # Nimrod uses ``<`` and ``<=``, etc. too:
   while p.tok.xkind in {pxLt, pxLe, pxGt, pxGe}:
-    var op = TokKindToStr(p.tok.xkind)
+    var op = tokKindToStr(p.tok.xkind)
     getTok(p, result)
     var a = result 
     var b = shiftExpression(p)
@@ -1443,7 +1443,7 @@ proc equalityExpression(p: var TParser): PNode =
   result = relationalExpression(p)
   # Nimrod uses ``==`` and ``!=`` too:
   while p.tok.xkind in {pxEquals, pxNeq}:
-    var op = TokKindToStr(p.tok.xkind)
+    var op = tokKindToStr(p.tok.xkind)
     getTok(p, result)
     var a = result 
     var b = relationalExpression(p)
@@ -1818,7 +1818,7 @@ proc parseConstructor(p: var TParser, pragmas: PNode,
   else:
     parMessage(p, errTokenExpected, ";")
   if result.sons[bodyPos].kind == nkEmpty:
-    DoImport((if isDestructor: "~" else: "") & origName, pragmas, p)
+    doImport((if isDestructor: "~" else: "") & origName, pragmas, p)
   elif isDestructor:
     addSon(pragmas, newIdentNodeP("destructor", p))
   if sonsLen(result.sons[pragmasPos]) == 0:
@@ -1862,8 +1862,8 @@ proc parseMethod(p: var TParser, origName: string, rettyp, pragmas: PNode,
   else:
     parMessage(p, errTokenExpected, ";")
   if result.sons[bodyPos].kind == nkEmpty:
-    if isStatic: DoImport(origName, pragmas, p)
-    else: DoImportCpp(origName, pragmas, p)
+    if isStatic: doImport(origName, pragmas, p)
+    else: doImportCpp(origName, pragmas, p)
   if sonsLen(result.sons[pragmasPos]) == 0:
     result.sons[pragmasPos] = ast.emptyNode
 
@@ -1880,7 +1880,7 @@ proc parseOperator(p: var TParser, origName: var string): bool =
   case p.tok.xkind
   of pxAmp..pxArrow:
     # ordinary operator symbol:
-    origName.add(TokKindToStr(p.tok.xkind))
+    origName.add(tokKindToStr(p.tok.xkind))
     getTok(p)
   of pxSymbol:
     if p.tok.s == "new" or p.tok.s == "delete":

compiler/c2nim/cpp.nim

@@ -226,7 +226,7 @@ proc skipUntilElifElseEndif(p: var TParser): TEndifMarker =
   
 proc parseIfdef(p: var TParser): PNode = 
   getTok(p) # skip #ifdef
-  ExpectIdent(p)
+  expectIdent(p)
   case p.tok.s
   of "__cplusplus":
     skipUntilEndif(p)
@@ -245,7 +245,7 @@ proc parseIfdef(p: var TParser): PNode =
 proc parseIfndef(p: var TParser): PNode = 
   result = ast.emptyNode
   getTok(p) # skip #ifndef
-  ExpectIdent(p)
+  expectIdent(p)
   if p.tok.s == c2nimSymbol: 
     skipLine(p)
     case skipUntilElifElseEndif(p)
@@ -282,11 +282,11 @@ proc parseIfDir(p: var TParser): PNode =
 proc parsePegLit(p: var TParser): TPeg =
   var col = getColumn(p.lex) + 2
   getTok(p)
-  if p.tok.xkind != pxStrLit: ExpectIdent(p)
+  if p.tok.xkind != pxStrLit: expectIdent(p)
   try:
     result = parsePeg(
       pattern = if p.tok.xkind == pxStrLit: p.tok.s else: escapePeg(p.tok.s), 
-      filename = p.lex.fileIdx.ToFilename, 
+      filename = p.lex.fileIdx.toFilename, 
       line = p.lex.linenumber, 
       col = col)
     getTok(p)
@@ -295,7 +295,7 @@ proc parsePegLit(p: var TParser): TPeg =
 
 proc parseMangleDir(p: var TParser) = 
   var pattern = parsePegLit(p)
-  if p.tok.xkind != pxStrLit: ExpectIdent(p)
+  if p.tok.xkind != pxStrLit: expectIdent(p)
   p.options.mangleRules.add((pattern, p.tok.s))
   getTok(p)
   eatNewLine(p, nil)
@@ -326,7 +326,7 @@ proc parseDir(p: var TParser): PNode =
   of "dynlib", "header", "prefix", "suffix", "class": 
     var key = p.tok.s
     getTok(p)
-    if p.tok.xkind != pxStrLit: ExpectIdent(p)
+    if p.tok.xkind != pxStrLit: expectIdent(p)
     discard setOption(p.options, key, p.tok.s)
     getTok(p)
     eatNewLine(p, nil)