summary refs log tree commit diff stats
path: root/tests/vm/twrongarray.nim
blob: c1514d0e9b6a43dc21f35440ac4eb3e5e08489c2 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
discard """
  errormsg: "cannot evaluate at compile time: size"
  line: 16
"""

#bug #1343

when false:
  proc one(dummy: int, size: int) =
    var x: array[size, int] # compile error: constant expression expected

  proc three(size: int) =
    var x: array[size * 1, int] # compile error: cannot evaluate at compile time: size

proc two(dummy: int, size: int) =
  var x: array[size * 1, int] # compiles, but shouldn't?
  #assert(x.len == size) # just for fun
div class='alt'>
804e2ac89 ^
3b7ef2288 ^
e25474154 ^

804e2ac89 ^
e25474154 ^



b50133b50 ^
8d734244b ^

f46870fe1 ^
f8dd74a07 ^


b50133b50 ^
e25474154 ^




b50133b50 ^

0ea4b71ee ^

e25474154 ^

6bc16904e ^

e25474154 ^

b50133b50 ^


48dd9679b ^
e25474154 ^
ff02ce2d5 ^

e25474154 ^






3b7ef2288 ^



e25474154 ^

804e2ac89 ^
e25474154 ^




8d734244b ^

f46870fe1 ^
f8dd74a07 ^


e25474154 ^
8d734244b ^
e25474154 ^




8d734244b ^
e25474154 ^

8d734244b ^


e25474154 ^



922e216b8 ^
e25474154 ^
b50133b50 ^
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129


                               
                                         











                                                        
                          
 

                                                 

                       

              

                                                 

                                                                                 

                                                    

                                                                               

                           
                                                                      
                                                                           
            






                                                                                
                                              
                                         
                                

                                                                                
            



                                                                                 
                                                                    

                                                
                                                                          


                                               
    




                                    

                                                                             

                                              

                                                                                

                                                                    

                                                                              


                                                                             
                                             
                                                                       

                                                                     






                                                                                 



                                            

                                                                                 
             




                                                                                

                                                                          
                                                                      


                                                     
 
                                                      




                                     
                                               

                                    


                                               



                                                                 
                                                                           
  
              
#
#
#           The Nimrod Compiler
#        (c) Copyright 2011 Andreas Rumpf
#
#    See the file "copying.txt", included in this
#    distribution, for details about the copyright.
#

# This module contains a word recognizer, i.e. a simple
# procedure which maps special words to an enumeration.
# It is primarily needed because Pascal's case statement
# does not support strings. Without this the code would
# be slow and unreadable.

import 
  hashes, strutils, idents

# Keywords must be kept sorted and within a range

type 
  TSpecialWord* = enum 
    wInvalid, 
    
    wAddr, wAnd, wAs, wAsm, wAtomic, 
    wBind, wBlock, wBreak, wCase, wCast, wConst, 
    wContinue, wConverter, wDiscard, wDistinct, wDiv, wElif, wElse, wEnd, wEnum, 
    wExcept, wFinally, wFor, wFrom, wGeneric, wIf, wImplies, wImport, wIn, 
    wInclude, wIs, wIsnot, wIterator, wLambda, wLet,
    wMacro, wMethod, wMod, wNil, 
    wNot, wNotin, wObject, wOf, wOr, wOut, wProc, wPtr, wRaise, wRef, wReturn, 
    wShl, wShr, wTemplate, wTry, wTuple, wType, wVar, wWhen, wWhile, wWith, 
    wWithout, wXor, wYield,
    
    wColon, wColonColon, wEquals, wDot, wDotDot, wHat, wStar, wMinus, 
    wMagic, wTypeCheck, wFinal, wProfiler, wObjChecks, wImportc, wExportc, 
    wExtern,
    wAlign, wNodecl, wPure, wVolatile, wRegister, wSideeffect, wHeader, 
    wNosideeffect, wNoreturn, wMerge, wLib, wDynlib, wCompilerproc, wProcVar, 
    wFatal, wError, wWarning, wHint, wLine, wPush, wPop, wDefine, wUndef, 
    wLinedir, wStacktrace, wLinetrace, wParallelBuild, wLink, wCompile, 
    wLinksys, wDeprecated, wVarargs, wByref, wCallconv, wBreakpoint, wDebugger, 
    wNimcall, wStdcall, wCdecl, wSafecall, wSyscall, wInline, wNoInline, 
    wFastcall, wClosure, wNoconv, wOn, wOff, wChecks, wRangechecks, 
    wBoundchecks, wOverflowchecks, wNilchecks,
    wFloatchecks, wNanChecks, wInfChecks,
    wAssertions, wWarnings, wW, 
    wHints, wOptimization, wSpeed, wSize, wNone, wPath, wP, wD, wU, wDebuginfo, 
    wCompileonly, wNolinking, wForcebuild, wF, wDeadCodeElim, wSafecode, 
    wPragma,
    wCompileTime, wGc, wRefc, wBoehm, wA, wOpt, wO, wApp, wConsole, wGui, 
    wPassc, wT, wPassl, wL, wListcmd, wGendoc, wGenmapping, wOs, wCpu, 
    wGenerate, wG, wC, wCpp, wBorrow, wRun, wR, wVerbosity, wV, wHelp, wH, 
    wSymbolFiles, wFieldChecks, wX, wVersion, wAdvanced, wSkipcfg, wSkipProjCfg, 
    wCc, wGenscript, wCheckPoint, wCheckPoints, wNoMain, wSubsChar, 
    wAcyclic, wShallow, wUnroll, wLinearScanEnd,
    wIndex, 
    wWrite, wPutEnv, wPrependEnv, wAppendEnv, wThreadVar, wEmit, wThreads,
    wRecursivePath, 
    wStdout,
    wIdeTools, wSuggest, wTrack, wDef, wContext
    
  TSpecialWords* = set[TSpecialWord]

const 
  oprLow* = ord(wColon)
  oprHigh* = ord(wHat)
  specialWords*: array[low(TSpecialWord)..high(TSpecialWord), string] = ["", 
    
    "addr", "and", "as", "asm", "atomic", 
    "bind", "block", "break", "case", "cast", 
    "const", "continue", "converter", "discard", "distinct", "div", "elif", 
    "else", "end", "enum", "except", "finally", "for", "from", "generic", "if", 
    "implies", "import", "in", "include", "is", "isnot", "iterator",
    "lambda", "let",
    "macro", "method", "mod", "nil", "not", "notin", "object", "of", "or", 
    "out", "proc", "ptr", "raise", "ref", "return", "shl", "shr", "template", 
    "try", "tuple", "type", "var", "when", "while", "with", "without", "xor",
    "yield",

    ":", "::", "=", ".", "..", "^", "*", "-",
    "magic", "typecheck", "final", "profiler", "objchecks", "importc", 
    "exportc", "extern",
    "align", "nodecl", "pure", "volatile", "register", "sideeffect", 
    "header", "nosideeffect", "noreturn", "merge", "lib", "dynlib", 
    "compilerproc", "procvar", "fatal", "error", "warning", "hint", "line", 
    "push", "pop", "define", "undef", "linedir", "stacktrace", "linetrace", 
    "parallelbuild", "link", "compile", "linksys", "deprecated", "varargs", 
    "byref", "callconv", "breakpoint", "debugger", "nimcall", "stdcall", 
    "cdecl", "safecall", "syscall", "inline", "noinline", "fastcall", "closure", 
    "noconv", "on", "off", "checks", "rangechecks", "boundchecks", 
    "overflowchecks", "nilchecks",
    "floatchecks", "nanchecks", "infchecks",

    "assertions", "warnings", "w", "hints", 
    "optimization", "speed", "size", "none", "path", "p", "d", "u", "debuginfo", 
    "compileonly", "nolinking", "forcebuild", "f", "deadcodeelim", "safecode", 
    "pragma",
    "compiletime", "gc", "refc", "boehm", "a", "opt", "o", "app", "console", 
    "gui", "passc", "t", "passl", "l", "listcmd", "gendoc", "genmapping", "os", 
    "cpu", "generate", "g", "c", "cpp", "borrow", "run", "r", "verbosity", "v", 
    "help", "h", "symbolfiles", "fieldchecks", "x", "version", "advanced", 
    "skipcfg", "skipprojcfg", "cc", "genscript", "checkpoint", "checkpoints", 
    "nomain", "subschar", "acyclic", "shallow", "unroll", "linearscanend",
    "index", 
    "write", "putenv", "prependenv", "appendenv", "threadvar", "emit",
    "threads", "recursivepath", 
    "stdout",
    "idetools", "suggest", "track", "def", "context"]

proc findStr*(a: openarray[string], s: string): int = 
  for i in countup(low(a), high(a)): 
    if cmpIgnoreStyle(a[i], s) == 0: 
      return i
  result = - 1

proc whichKeyword*(id: PIdent): TSpecialWord = 
  if id.id < 0: result = wInvalid
  else: result = TSpecialWord(id.id)

proc whichKeyword*(id: String): TSpecialWord = 
  result = whichKeyword(getIdent(id))
  
proc initSpecials() = 
  # initialize the keywords:
  for s in countup(succ(low(specialWords)), high(specialWords)): 
    getIdent(specialWords[s], hashIgnoreStyle(specialWords[s])).id = ord(s)
  
initSpecials()