====== C3 - zpracování deklarací - sémantická analýza =====

[[http://gitlab.fjfi.cvut.cz/culikzde/view/-/blob/master/tutorial/cecko3_compiler.py|cecko3_compiler.py]]


{{prekl::c3_decl.png?800}}

<code Python>
from __future__ import print_function
from cecko3_parser import *

class Compiler (Parser) :

   def __init__ (self) :
       super (Compiler, self).__init__ ()
       self.display = [ ]

   # initialization

   def on_start_program (self, decl_list) :
       decl_list.item_name = ""
       decl_list.item_qual = ""
       decl_list.item_dict = { }
       decl_list.item_list = [ ]
       self.display.append (decl_list)

   # scope

   def enter (self, item) :
       top = self.display [-1]
       top.item_dict [item.item_name] = item
       top.item_list.append (item)
       item.item_context = top
       if top.item_qual == "" :
          item.item_qual = item.item_name
       else :
          item.item_qual = top.item_qual + "." + item.item_name

   def openScope (self, item) :
       if not hasattr (item, "item_dict") :
          item.item_dict = { }
       if not hasattr (item, "item_list") :
          item.item_list = [ ]
       self.display.append (item)

   def closeScope (self) :
       self.display.pop ()

   def lookup (self, name) :
       result = None
       inx = len (self.display) - 1
       while result == None and inx >= 0 :
          result = self.display [inx].item_dict.get (name)
          inx = inx - 1
       return result

   # namespace

   def open_namespace (self, ns) :
       ns.item_name = ns.name
       ns.item_expand = True
       ns.item_icon = "namespace"
       self.copy_location (ns)
       self.enter (ns)
       self.selectColor (ns)
       self.markDefn (ns)

       self.openScope (ns)
       self.openCompletion (ns, outside = True)

   def close_namespace (self, ns) :
       self.closeCompletion (ns, outside = True)
       self.closeScope ()

   def copy_location (self, obj) :
       obj.src_file = self.prevFileInx
       obj.src_line = self.prevLineNum
       obj.src_column = self.prevColNum
       obj.src_pos = self.prevByteOfs
       obj.src_end = self.prevEndOfs

   # class

   def begin_class (self, cls) :
       self.openRegion (cls) # region with background color

   def open_class (self, cls) :
       cls.item_name = cls.name
       cls.item_expand = True
       cls.item_icon = "class"
       self.copy_location (cls)
       self.enter (cls) # add declaration into current scope
       self.selectColor (cls)
       self.markDefn (cls) # mark as definition (in editor)

       self.openScope (cls) # open scope for identifiers
       self.openCompletion (cls, outside = True) # area with text completion

   def close_class (self, cls) :
       self.closeCompletion (cls, outside = True)
       self.closeScope ()

   def end_class (self, cls) :
       self.closeRegion ()

   # enumeration type

   def open_enum (self, typ) :
       typ.item_name = typ.name
       typ.item_expand = True
       typ.item_icon = "enum"
       self.copy_location (typ)
       self.enter (typ) # add declaration into current scope
       self.selectColor (typ)
       self.markDefn (typ) # mark as definition (in editor)

       self.openScope (typ) # open scope for identifiers
       self.openCompletion (typ, outside = True) # area with text completion

   def close_enum (self, typ) :
       self.closeCompletion (typ, outside = True)
       self.closeScope ()

   def on_enum_item (self, decl) :
       decl.item_name = decl.name
       decl.item_icon = "variable"
       self.copy_location (decl)
       self.enter (decl)
       self.selectColor (decl)
       self.markDefn (decl)

   # simple declaration

   def on_simple_decl (self, decl) :
       decl.item_name = decl.name
       decl.item_icon = "variable"
       self.copy_location (decl)
       self.enter (decl)
       self.selectColor (decl)
       self.markDefn (decl)

   def on_local_decl (self, stat) :
       self.on_simple_decl (stat.inner_decl)

   def open_parameters (self, decl) :
       self.openScope (decl)

   def on_param_decl (self, decl) :
       self.on_simple_decl (decl)

   def close_parameters (self, decl) :
       self.closeScope ()

   def open_function (self, decl) :
       decl.item_icon = "function"
       self.openScope (decl)
       self.openRegion (decl)
       self.openCompletion (decl, outside = True)

   def close_function (self, decl) :
       self.closeCompletion (decl, outside = True)
       self.closeRegion ()
       self.closeScope ()

   # expression

   def on_variable_expr (self, expr) :
       expr.item_name = expr.name
       # print ("ident_expr", expr.item_name)
       expr.item_decl = self.lookup (expr.item_name)
       if expr.item_decl != None :
          expr.item_qual = expr.item_decl.item_qual
       self.markUsage (expr, expr.item_decl)
</code>

V textovém editoru stiskem pravého tlačítka myši můžeme vybrat **"Find compiler data"**

{{prekl::c3_tree.png?800}}