yu/decl.lua

   1 require "yu.visitor"
   2 require "yu.type"
   3
   4 local is=yu.is
   5 local getTypeDecl,newTypeRef=yu.getTypeDecl,yu.newTypeRef
   6 local ipairs,print=ipairs,print
   7
   8 module("yu",package.seeall)
   9
  10 local pre={}
  11 local post={}
  12
  13 local isConst,isDecl,isGlobalDecl=isConst,isDecl,isGlobalDecl
  14 local is=yu.is
  15 local function makeNamePrefix(stack)
  16         local out='_yu'
  17         for i,n in ipairs(stack) do
  18                 if out then
  19                         out=out..'_'..n
  20                 else
  21                         out=n
  22                 end
  23         end
  24         return out or ''
  25 end
  26
  27 function newDeclCollector()
  28
  29         return yu.newVisitor({
  30                 pre=pre,
  31                 post=post,
  32
  33                 nameStack=yu.newStack(),
  34                 scopeStack=yu.newStack(),
  35
  36                 currentNamePrefix="",
  37                 currentScope=false,
  38
  39                 pushName=function(self,name)
  40                         self.nameStack:push(name)
  41                         self.currentNamePrefix=makeNamePrefix(self.nameStack.stack)
  42                 end,
  43
  44                 popName=function(self)
  45                         self.nameStack:pop()
  46                         self.currentNamePrefix=makeNamePrefix(self.nameStack.stack)
  47                 end,
  48
  49                 pushScope=function(self)
  50                         local scope={}
  51                         self.scopeStack:push(scope)
  52                         self.currentScope=scope
  53                         self.currentNode.scope=scope
  54                         return scope
  55                 end,
  56
  57                 popScope=function(self)
  58                         self.currentScope=self.scopeStack:pop()
  59                         return self.currentScope
  60                 end,
  61
  62                 addEachDecl=function(self,list)
  63                         for i,n in ipairs(list) do
  64                                 if isDecl(n) or is(n.tag,"public","private") then
  65                                         self:addDecl(n)
  66                                 end
  67                         end
  68                 end,
  69
  70                 addDecl=function(self,decl)
  71                         local currentScope=self.currentScope
  72
  73                         if isBuiltinType(decl.name) then
  74                                 self:err(decl.name..' is builtin type',decl,self.currentModule)
  75                         end
  76
  77                         local tag=decl.tag
  78
  79                         if tag=="private" then
  80                                 currentScope.private=true
  81                                 return
  82                         elseif tag=="public" then
  83                                 currentScope.private=false
  84                                 return
  85                         end
  86
  87                         if tag=="vardecl" then
  88                                 for i,var in ipairs(decl.vars) do
  89                                         var.vtype=decl.vtype
  90                                         self:addDecl(var)
  91                                 end
  92                                 return
  93                         end
  94
  95                         if tag=="import" then
  96                                 decl.name=decl.alias
  97                         end
  98
  99                         local scope=currentScope
 100                         decl.private=scope.private
 101
 102                         local name=decl.name
 103                         local decl0=scope[name]
 104
 105                         if decl0 then  --duplicated?
 106                                 local tag0=decl0.tag
 107                                 if tag==tag0 and is(tag,"funcdecl","methoddecl") then
 108                                         --TODO:function overload
 109                                         if decl0.private ~= decl.private then
 110                                                 self:err('function overload must be both private or public',decl)
 111                                         end
 112
 113                                         local dd=decl0
 114                                         local n=1
 115                                         while true do
 116                                                 local d1=dd.nextProto
 117                                                 if not d1 then
 118                                                         dd.nextProto=decl
 119                                                         break
 120                                                 end
 121                                                 n=n+1
 122                                                 dd=d1
 123                                         end
 124                                         decl.protoId=n
 125                                 else
 126                                         self:err(
 127                                                 "duplicated declaration:'"..decl.name
 128                                                 .."',first defined at"
 129                                                 ..getTokenPosString(decl0,self.currentModule)
 130                                                 ,decl,self.currentModule)
 131                                 end
 132                         else
 133                                 scope[decl.name]=decl
 134                         end
 135
 136                         if decl.alias then
 137                                 decl.fullname=decl.alias
 138                         else
 139                                 if decl.extern then
 140                                         decl.fullname=decl.name
 141                                 else
 142                                         local currentNamePrefix=self.currentNamePrefix
 143
 144                                         if currentNamePrefix~='' then
 145                                                 decl.fullname=currentNamePrefix..'_'..name
 146                                         else
 147                                                 decl.fullname=name
 148                                         end
 149
 150                                         if decl.protoId then
 151                                                 decl.fullname='_'..decl.protoId..decl.fullname
 152                                         end
 153
 154                                 end
 155                         end
 156
 157
 158
 159                         -- print("..added decl:",decl.tag,decl.name,decl.fullname,decl.vtype)
 160                 end
 161
 162                 }
 163         )
 164 end
 165
 166
 167 -------------
 168 function pre.any(vi,n)
 169         if vi.currentModule then
 170                 n.module=vi.currentModule
 171         end
 172 end
 173
 174 function pre.module(vi,m)
 175         vi:pushScope()
 176         vi:pushName(m.name)
 177         vi.currentModule=m
 178         m.module=m
 179 end
 180
 181 function post.module(vi,m)
 182         vi:popName()
 183         vi:popScope()
 184
 185 end
 186
 187 ---------------
 188
 189 function pre.block(vi,b,parent)
 190         -- if not is(parent.tag,'funcdecl','methoddecl','forstmt','catch','foreachstmt')
 191                 -- b.scope=vi:pushScope()
 192         -- end
 193         vi:addEachDecl(b)
 194
 195         local pn=vi.nodeStack:peek(1)
 196         if pn.tag=='module' then -- top block? add named imported module into scope
 197                 for i,h in ipairs(pn.heads) do
 198                         if h.tag=='import' and h.alias then
 199                                 h.type=moduleMetaType
 200                                 vi:addDecl(h)
 201                         end
 202                 end
 203         end
 204
 205 end
 206
 207 function post.block(vi,b)
 208         -- vi:popScope()
 209 end
 210
 211 function pre.dostmt(vi,d)
 212         vi:pushScope()
 213 end
 214
 215 function post.dostmt(vi,d)
 216         vi:popScope()
 217 end
 218
 219 -----------
 220
 221 function pre.extern(vi,e)
 222         for i,s in ipairs(e.decls) do
 223                 if isDecl(s) or is(s.tag,"public","private") then
 224                         vi:addDecl(s)
 225                 end
 226         end
 227 end
 228
 229 -----------
 230
 231
 232 local function spreadVarTypes(vars,vardecl)
 233         local lasttype=nil
 234         for i=#vars,1,-1 do
 235                 local var=vars[i]
 236                 if var.type then
 237                         lasttype=var.type
 238                 elseif lasttype then
 239                         var.type=lasttype
 240                 else
 241                         -- table.foreach(var,print)
 242                         return yu.compileErr("type identifier expected",var,vardecl.module)
 243                 end
 244         end
 245 end
 246
 247
 248 function pre:vardecl(vd)
 249         local vars=vd.vars
 250         if vd.def then --should no type id
 251                 for i,var in ipairs(vars) do
 252                         if var.type then return self:err("unnecessary type identifier",var.type) end
 253                 end
 254                 --todo:mulitple return
 255                 for i,var in ipairs(vars) do
 256                         local v=vd.values[i]
 257                         var.value=v
 258                         var.type=newTypeRef(v)
 259                 end
 260
 261         else
 262                 spreadVarTypes(vars,vd)
 263                 --todo:mulitple return
 264                 if vd.values then
 265                         for i,var in ipairs(vars) do
 266                                 var.value=vd.values[i]
 267                         end
 268                 end
 269
 270         end
 271         return true
 272 end
 273
 274
 275
 276 function pre.funcdecl(vi,f)
 277         vi:pushName(f.name)
 278         vi:pushScope()
 279 end
 280
 281 function post.funcdecl(vi,f)
 282         vi:popScope()
 283         vi:popName()
 284 end
 285
 286 function pre.closure(vi,f)
 287         f.name='C'
 288         vi:pushName(f.name)
 289         vi:pushScope()
 290 end
 291
 292 function post.closure(vi,f)
 293         vi:popScope()
 294         vi:popName()
 295 end
 296
 297
 298 -----------
 299 function pre.methoddecl(vi,f,parent)
 300         vi:pushName(f.name)
 301         vi:pushScope()
 302         if f.abstract then
 303                 parent.abstract=true
 304         end
 305 end
 306
 307 function post.methoddecl(vi,f)
 308
 309         vi:popScope()
 310         vi:popName()
 311 end
 312
 313 -----------
 314 function pre.externfunc(vi,f)
 315         vi:pushName(f.name)
 316         vi:pushScope()
 317 end
 318
 319 function post.externfunc(vi,f)
 320         vi:popScope()
 321         vi:popName()
 322 end
 323
 324 -----------
 325 function pre.externmethod(vi,f)
 326         vi:pushName(f.name)
 327         vi:pushScope()
 328 end
 329
 330 function post.externmethod(vi,f)
 331         vi:popScope()
 332         vi:popName()
 333 end
 334 ------------
 335 function pre.functype(vi,ft)
 336         local args=ft.args
 337         if args then
 338                 spreadVarTypes(args,ft)
 339                 for i,arg in ipairs(args) do
 340                         vi:addDecl(arg)
 341                 end
 342         end
 343
 344 end
 345
 346 function post.functype(vi,ft)
 347
 348 end
 349
 350
 351
 352 ------------
 353 function pre.catch(vi,c)
 354         vi:pushScope()
 355         for i,v in ipairs(c.vars) do
 356                 vi:addDecl(v)
 357         end
 358 end
 359
 360 function post.catch(vi,c)
 361         vi:popScope()
 362 end
 363
 364 ------------
 365 function pre.foreachstmt(vi,f)
 366         vi:pushScope()
 367         for i,v in ipairs(f.vars) do
 368                 vi:addDecl(v)
 369         end
 370 end
 371
 372 function post.foreachstmt(vi,f)
 373         vi:popScope()
 374 end
 375
 376
 377 function pre.forstmt(vi,f)
 378         vi:pushScope()
 379         f.var.type=numberType
 380         f.var.vtype='local'
 381         vi:addDecl(f.var)
 382 end
 383
 384 function post.forstmt(vi,f)
 385         vi:popScope()
 386 end
 387
 388 ----------
 389
 390 function pre.classdecl(vi,c)
 391         c.type=classMetaType
 392         vi:pushName(c.name)
 393         vi:pushScope()
 394 end
 395
 396 function post.classdecl(vi,c)
 397         if c.tvars then
 398                 for i,v in ipairs(c.tvars) do
 399                         vi:addDecl(v)
 400                 end
 401         end
 402
 403         if c.decls then
 404                 for i,d in ipairs(c.decls) do
 405                         vi:addDecl(d)
 406                 end
 407         end
 408
 409         vi:popScope()
 410         vi:popName()
 411 end
 412
 413 function pre.externclass(vi,c)
 414         vi:pushName(c.name)
 415         vi:pushScope()
 416         if c.decls then
 417                 for i,d in ipairs(c.decls) do
 418                         vi:addDecl(d)
 419                 end
 420         end
 421 end
 422
 423 function post.externclass(vi,c)
 424         vi:popScope()
 425         vi:popName()
 426 end
 427
 428
 429 ---
 430 function pre.enumdecl(vi,e)
 431         vi:pushName(e.name)
 432         vi:pushScope()
 433
 434         for i,ei in ipairs(e.items) do
 435                 vi:addDecl(ei)
 436         end
 437
 438 end
 439
 440 function post.enumdecl(vi,c)
 441         vi:popScope()
 442         vi:popName()
 443
 444 end
 445