DokuWiki

You've loaded an old revision of the document! If you save it, you will create a new version with this data.

====== C-- zpracování deklarací =====

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

# cmm_comp.py

from __future__ import print_function

import os, copy
import inspect

from cmm_parser import *
from cmm_product import *

from input import quoteString
from util import findColor

from code import *
# from cmm_code import *

from grammar import Grammar
from toparser  import ToParser
from toproduct import ToProduct

# --------------------------------------------------------------------------

class NoQuote (object) :
   def __init__ (self, value) :
       self.value = value
   def __repr__ (self) :
       return self.value

# --------------------------------------------------------------------------

class CmmCompiler (Parser) :
   def __init__ (self) :
       super (CmmCompiler, self).__init__ ()

self.win = None
       self.edit = None

self.global_scope = Namespace ()
       self.global_scope.item_name = ""
       self.global_scope.hidden_scope = True # do not print scope name

self.display = [ self.global_scope ]

self.top_decl_list = None

self.enable_declaration_stack = [ False ]
       self.remember_compound_name = None

self.init_types ()

def compile_program (self) :
       self.top_decl_list = CmmDeclSect ()
       self.storeLocation (self.top_decl_list)
       while self.token != self.eos :
          self.top_decl_list.items.append (self.parse_declaration ())

# scope

def enter (self, item) :
       inx = len (self.display) - 1
       scope = self.display [inx]
       while scope.search_only and inx > 0 :
          inx = inx - 1
          scope = self.display [inx]
       if inx < 0 :
          self.error ("All scopes are search-only")
       self.enterIntoScope (scope, item)
       item.item_place = self.display [-1] # last scope , even search_only

def enterIntoScope (self, scope, item) :
       scope.item_dict [item.item_name] = item
       scope.item_list.append (item)

item.item_place = scope

item.item_context = scope

if hasattr (scope, "item_qual") and scope.item_qual != None and scope.item_qual != "" :
          item.item_qual = scope.item_qual + "." + item.item_name
       else :
          item.item_qual = item.item_name

# self.selectColor (item, defn = True)

def openScope (self, scope) :
       self.display.append (scope)

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

def searchScope (self, scope, name) :
       return scope.item_dict.get (name, None)

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, None)
          inx = inx - 1
       return result

def openSearchOnlyScope (self, scope) :
       look = copy.copy (scope)
       look.search_only = True
       self.openScope (look)

# special scopes

def register (self, scope, name, item) :
       item.item_name = name
       scope.registered_scopes [name] = item

item.item_context = scope

if hasattr (scope, "item_qual") and scope.item_qual != None and scope.item_qual != "" :
          item.item_qual = scope.item_qual + "." + item.item_name
       else :
          item.item_qual = item.item_name

# namespace

def on_start_namespace (self, ns_decl) :
       pass

def on_namespace (self, ns_decl) :
       module = Namespace () # create Namespace object from code.py
       module.link_code (ns_decl) # connect with parsed declaration (module.link_code <--> ns_decl.item_ref)
       module.item_name = ns_decl.simp_name.id # store name
       self.copy_name_location (module, ns_decl.simp_name) # store location
       self.enter (module) # add identifier into scope
       self.selectColor (module, table = "namespaceColors")
       self.markDefn (module) # set attributes in text editor
       self.markOutline (module)
       self.custom_namespace (ns_decl)

def on_open_namespace (self, ns_decl) :
       module = ns_decl.item_ref
       self.openScope (module) # scope for identifiers
       self.openCompletion (module) # area with text completion

def on_close_namespace (self, ns_decl) :
       module = ns_decl.item_ref
       self.closeCompletion (module)
       self.closeScope ()

def on_stop_namespace (self, ns_decl) :
       pass

# class

def on_start_class (self, cls_decl) :
       cls = Class ()
       cls.link_code (cls_decl)
       # self.openRegion (cls) # region with background color

def on_class (self, cls_decl) :
       cls = cls_decl.item_ref
       cls.item_name = cls_decl.simp_name.id
       self.copy_name_location (cls, cls_decl.simp_name)
       self.enter (cls)
       self.selectColor (cls, table = "classColors")
       self.markDefn (cls)
       self.markOutline (cls)
       self.custom_class (cls_decl)

def on_open_class (self, cls_decl) :
       cls = cls_decl.item_ref
       self.custom_open_class (cls)
       self.openScope (cls)
       self.openCompletion (cls)

def on_close_class (self, cls_decl) :
       cls = cls_decl.item_ref
       self.closeCompletion (cls)
       self.closeScope ()

def on_stop_class (self, cls_decl) :
       # self.closeRegion ()
       pass

# enum

def on_start_enum (self, enum_decl) :
       enum = Enum ()
       enum.link_code (enum_decl)
       self.openRegion (enum) # region with background color

def on_enum (self, enum_decl) :
       enum = enum_decl.item_ref
       enum.item_name = enum_decl.simp_name.id
       self.copy_name_location (enum, enum_decl.simp_name)
       self.enter (enum)
       self.selectColor (enum, table = "enumColors")
       self.markDefn (enum)
       self.markOutline (enum)

def on_open_enum (self, enum_decl) :
       enum = enum_decl.item_ref
       self.openScope (enum)
       self.openCompletion (enum)

def on_enum_item (self, decl) :
       item = EnumItem ()
       item.item_name = decl.simp_name.id
       item.link_code (decl)
       self.copy_name_location (item, decl.simp_name)
       self.enter (item)
       self.selectColor (item, table = "variableColors")
       self.markDefn (item)

def on_close_enum (self, enum_decl) :
       enum = enum_decl.item_ref
       self.closeCompletion (enum)
       self.closeScope ()

def on_stop_enum (self, enum_decl) :
       self.closeRegion ()

# typedef

def on_typedef (self, t) :
       typedef = Typedef ()
       typedef.link_code (t)
       self.copy_declarator_name (typedef, t.decl)
       self.copy_declarator_location (typedef, t.decl)
       self.enter (typedef)
       self.selectColor (typedef, table = "typedefColors")
       self.markDefn (typedef)
       self.markOutline (typedef)

# simple declaration

def on_simple_item (self, simple_declaration) :
       simple_item = simple_declaration.items [-1] # get above simple declaration
       variable = Variable ()
       variable.link_code (simple_item)
       variable.item_code_decl = simple_declaration # !?

"is it function"
       func_spec = self.get_function_specifier (simple_item.decl)
       if func_spec != None :
          variable.is_function = True
          variable.item_icon = "function"

self.copy_declarator_name (variable, simple_item.decl)
       self.copy_declarator_location (variable, simple_item.decl)

init_type = simple_declaration.type_spec.item_type
       variable.item_type = self.get_declarator_type (init_type, simple_item.decl)

"constructor or destructor"
       if self.ctor_declarator (simple_item.decl) :
          expr = simple_declaration.type_spec
          if expr.kind == expr.simpleName :
             func_name = expr.id
             variable.item_name = func_name
             cls = self.display [-1]
             if isinstance (cls, Class) :
                if func_name == cls.item_name :
                   variable.is_constructor = True
                   # if func_spec != None :
                   #    if simple_declaration.a_destructor :
                   #       variable.is_destructor = True
                   #    else :
                   #       variable.is_constructor = True

self.enter (variable)
       if variable.is_function :
          self.selectColor (variable, table = "functionColors")
       else :
          self.selectColor (variable, table = "variableColors")
       self.markDefn (variable)

self.custom_simple_item (simple_declaration, simple_item)

def on_simple_declaration (self, simple_decl) :
       self.custom_simple_declaration (simple_decl)

def on_simple_statement (self, stat) :
       self.custom_simple_statement (stat)

def on_block_statement (self, stat) :
       self.custom_block_statement (stat)

def ctor_declarator (self, decl) :
       return ( decl.kind == decl.emptyDeclarator and
                len (decl.ptr_spec.items) == 0 and
                len (decl.cont_spec.items) == 1 and
                isinstance (decl.cont_spec.items[0], CmmFunctionSpecifier))

def get_simple_name (self, qual_name) :
       result = ""
       if qual_name.kind == qual_name.simpleName :
          result = qual_name.id
       return result

def copy_declarator_name (self, target, declarator) :
       if declarator != None :
          while declarator.kind == declarator.nestedDeclarator :
             declarator = declarator.inner_declarator
          if declarator.kind == declarator.basicDeclarator :
             target.item_name = self.get_simple_name (declarator.qual_name) # !?
          else :
             target.item_name = ""

def copy_declarator_location (self, target, declarator) :
       if declarator != None :
          while declarator.kind == declarator.nestedDeclarator :
             declarator = declarator.inner_declarator
          if declarator.kind == declarator.basicDeclarator :
             self.copy_name_location (target, declarator.qual_name)

# function

def on_open_function (self, simple_declaration) :
       if len (simple_declaration.items) != 0 : # !?
          simple_item = simple_declaration.items [-1]
          variable = simple_item.item_ref
          if not variable.is_function :
             self.openSearchOnlyScope (variable) # only for lookup, not for declarations
             self.openCompletion (variable, outside = True)
          if variable.is_function :
             func = variable

self.openRegion (func) # region with background color
             self.openScope (func)

func_spec = self.get_function_specifier (simple_item.decl)
             self.enter_parameters (func_spec.parameters)

self.openCompletion (func, outside = True)
             self.markOutline (func)

self.register (func, "(local)", func.local_scope)
             func.local_scope.hidden_scope = True # do not print (local)
             self.openScope (func.local_scope)

def on_close_function (self, simple_declaration) :
       if len (simple_declaration.items) != 0 : # !?
          simple_item = simple_declaration.items [-1]
          variable = simple_item.item_ref
          if not variable.is_function :
             variable.item_body = simple_declaration.body
             self.closeCompletion (variable, outside = True)
             self.closeScope ()
          if variable.is_function :
             func = variable
             func.item_body = simple_declaration.body
             self.closeCompletion (func, outside = True)
             self.closeScope () # local variables
             self.closeScope () # parameters
             self.closeRegion ()
             # simple_declaration.body.item_label = func.item_name
          self.custom_statement (variable, simple_declaration.body)

def get_function_specifier (self, declarator) :
       result = None
       while declarator != None and result == None :
          inx = len (declarator.cont_spec.items) - 1
          while inx >= 0 :
             c = declarator.cont_spec.items [inx]
             if isinstance (c, CmmFunctionSpecifier) :
                result = c
             inx = inx - 1

if result == None :
             if declarator.kind == declarator.nestedDeclarator :
                declarator = declarator.inner_declarator
             else :
                declarator = None

return result

def enter_parameters (self, param_list) :
       for param in param_list.items :
           if param.kind == param.plainParam : # !?
              variable = Variable ()
              variable.link_code (param)

self.copy_declarator_name (variable, param.decl)
              self.copy_declarator_location (variable, param.decl)

init_type = getattr (param.type_spec, "item_type", None)
              variable.item_type = self.get_declarator_type (init_type, param.decl)

self.enter (variable)
              self.selectColor (variable, table = "variableColors")
              self.markDefn (variable)

# names

def on_base_name (self, qual_name) :
       decl = None
       if qual_name.kind == qual_name.globalName :
          inner_name = qual_name.inner_name
          if inner_name.kind == inner_name.simpleName :
             decl = self.searchScope (self.global_scope, inner_name.id)
       else :
          if qual_name.kind == qual_name.simpleName :
             decl = self.lookup (qual_name.id)

if decl != None :
          if isinstance (decl, Class) or isinstance (decl, Enum) or isinstance (decl, Typedef) :
             qual_name.type_flag = True
             # qual_name.item_type = self.get_type_decl (qual_name)

"add item_decl"
       qual_name.item_decl = decl
       self.custom_base_name (qual_name)

def is_template (self, qual_name) :
       decl = qual_name.item_decl
       result = decl != None and getattr (decl, "item_code", None) != None and getattr (decl.item_code, "template_decl", None) != None
       return result

def is_cont_template (self, cont_name) :
       return False

def on_template_args (self, qual_name) :
       if qual_name.item_decl != None :
          qual_name.item_qual = self.get_instance_identification (qual_name.item_decl)
          self.create_instance (qual_name)
       qual_name.item_decl = qual_name.left.item_decl # !?

def on_begin_compound_name (self, qual_name) :
       self.remember_compound_name = qual_name

def on_cont_name (self, qual_name) :
       decl = self.remember_compound_name
       self.remember_compound_name = None
       if decl != None and getattr (decl, "item_dict", None) != None :
          qual_name.item_decl = self.searchScope (decl, qual_name.id)

def on_compound_name (self, qual_name) :
       cont = qual_name.right
       qual_name.item_decl = cont.item_decl

# type or expression

def is_binary_expression (self, expr) :
       # type names cannot be left operand in binary expressions
       return not expr.type_flag

def is_expression (self, expr) :
       return not expr.type_flag

def is_value_parameter (self, expr) :
       return not expr.type_flag

def on_begin_flexible_expr (self) :
       # enable strange declarations (declaration starting with unknown identifier and asterisk)
       self.enable_declaration_stack.append (True)

def on_end_flexible_expr (self) :
       # disable strange declarations
       self.enable_declaration_stack.pop ()

def on_name_expr (self, expr) :
       # rember strange declaratrion flag and disable strange declarations
       expr.remember_enable_declaration = self.enable_declaration_stack [-1]
       self.enable_declaration_stack [-1] = False

def on_other_expr (self) :
       # disable strange declarations
       self.enable_declaration_stack [-1] = False

def is_multiplicative_expression (self, expr) :
       return not expr.type_flag and not expr.remember_enable_declaration

def is_and_expression (self, expr) :
       return not expr.type_flag and not expr.remember_enable_declaration

def on_bit_not_expr (self, expr) :
       expr.type_flag = expr.param.type_flag

def is_postfix_expression (self, expr) :
       if self.tokenText == "(" :
          return True
          # return not expr.type_flag and not expr.remember_enable_declaration
          # return not expr.type_flag
       else :
          return not expr.type_flag

def is_mul (self, expr) :
       return False

def is_add (self, expr) :
       return False

def is_constructor (self, expr) :
       return False

# location and style

def copy_location (self, target, source) :
       target.src_file = source.src_file
       target.src_line = source.src_line
       target.src_column = source.src_column
       target.src_pos = source.src_pos
       target.src_end = source.src_end

def copy_name_location (self, target, qual_name) :
       source = qual_name
       if source != None :
          if source.kind == source.compoundName :
             source = source.right
          self.copy_location (target, source)

def copy_style (self, target, source) :
       if source != None :
          if getattr (source, "item_ink", None) != None:
             target.item_ink = source.item_ink
          if getattr (source, "item_paper", None) != None:
             target.item_paper = source.item_paper
          if getattr (source, "item_icon", None) != None:
             target.item_icon = source.item_icon

# name as a string

def get_name (self, qual_name) :
       result = ""

if qual_name.kind == qual_name.simpleName :
          result = qual_name.id
       elif qual_name.kind == qual_name.specialName :
          result = qual_name.spec_func.spec_name # !?
       elif qual_name.kind == qual_name.compoundName :
          result = self.get_name (qual_name.left) + "::" + self.get_name (qual_name.right)
       elif qual_name.kind == qual_name.globalName :
           result = "::" + self.get_name (qual_name.inner_name)
       elif qual_name.kind == qual_name.destructorName :
           result = "~" + self.get_name (qual_name.inner_name)
       elif qual_name.kind == qual_name.templateName :
        result = self.get_name (qual_name.left) + "<???>" # !?

if result == "" :
          result = "???"
       return result

# type specifiers

def on_type_name (self, expr) :
       expr.type_flag = True
       expr.item_type = expr.qual_name.item_type

def on_cv_specifier (self, expr) :
       expr.type_flag = True

type = expr.param.item_type

if isinstance (type, NamedType) :
          new_type = NamedType ()
          new_type.type_const = type.type_const
          new_type.type_volatile = type.type_volatile
          new_type.type_name = type.type_name
          new_type.type_decl = type.type_decl

if type != None : # !?
          if expr.kind == expr.constSpec :
             type.type_const = True
          if expr.kind == expr.volatileSpec :
             type.type_volatile = True

expr.item_type = type

def on_type_specifier (self, expr) :
       expr.type_flag = True

type = self.get_type_spec (expr)
       expr.item_type = type
       self.copy_location (type, expr)
       self.copy_style (type, expr)

# if isinstance (type, NamedType) :
       #    self.copy_style (type, type.type_decl)
       #    self.markUsage (type)

self.custom_type_specifiers (expr, type)

def get_type_decl (self, obj) :
       result = None
       if obj.item_decl != None :
          if ( isinstance (obj.item_decl, Class) or
               isinstance (obj.item_decl, Enum) or
               isinstance (obj.item_decl, Typedef) or
               isinstance (obj.item_decl, Unknown) ) :
             result = obj.item_decl
       return result

def get_named_type (self, qual_name) :
       result = NamedType ()
       result.type_name = self.get_name (qual_name)
       result.type_decl = self.get_type_decl (qual_name)
       if isinstance (qual_name, CmmTemplateName) :
          result.type_name = self.get_name (qual_name.left) # !? name without < >
          result.type_args =  qual_name.template_args
          result.type_args = [ ]
          for arg in qual_name.template_args.items :
              # type_spec = arg.value.type_spec
              # result.type_args.append (type_spec.item_type) # !? missing pointers, ...
              param = arg.value
              init_type = getattr (param.type_spec, "item_type", None)
              param_type = self.get_declarator_type (init_type, param.decl)
              result.type_args.append (param_type)
       return result

def get_type_spec (self, type_spec) :
       result = None
       # qual_name = type_spec.basic_name
       # if qual_name != None :
       #    result = self.get_named_type (qual_name)
       # else :
       if 1 :
          result = SimpleType ()
          if type_spec.a_void : result.type_void = True
          elif type_spec.a_bool : result.type_bool = True
          elif type_spec.a_char : result.type_char = True
          elif type_spec.a_wchar : result.type_wchar = True
          elif type_spec.a_short : result.type_short = True
          elif type_spec.a_int : result.type_int = True
          elif type_spec.a_long : result.type_long = True
          elif type_spec.a_float : result.type_float = True
          elif type_spec.a_double : result.type_double = True

if type_spec.a_signed :
             result.type_signed = True
          elif type_spec.a_unsigned :
             result.type_unsigned = True

# if type_spec.a_const :
       #    result.type_const = True
       # if type_spec.a_volatile :
       #    result.type_volatile = True

return result

# declarator type

def get_declarator_type (self, init_type, declarator) :
       result = init_type
       while declarator != None :
          for p in declarator.ptr_spec.items :
             last = result
             if p.kind == p.pointerSpec :
                result = PointerType ()
                result.type_from = last
             if p.kind == p.referenceSpec :
                result = ReferenceType ()
                result.type_from = last
             if p.cv_spec.cv_const :
                result.type_const = True
             if p.cv_spec.cv_volatile :
                result.type_volatile = True

if declarator.kind != declarator.emptyDeclarator :
             inx = len (declarator.cont_spec.items) - 1
             while inx >= 0 :
                c = declarator.cont_spec.items [inx]
                last = result
                if isinstance (c, CmmFunctionSpecifier) :
                   result = FunctionType ()
                   result.type_from = last
                if isinstance (c, CmmArraySpecifier) :
                   result = ArrayType ()
                   result.type_from = last
                inx = inx - 1

if declarator.kind == declarator.nestedDeclarator :
             declarator = declarator.inner_declarator
          else :
             declarator = None

return result

# expression

def on_ident_expr (self, expr) :
       self.markUsage (expr, expr.item_decl)

# !?
       if self.get_type_decl (expr) != None :
          expr.item_type = self.get_named_type (expr)

if expr.item_decl != None and getattr (expr.item_decl, "item_type", None) != None :
          expr.item_type = expr.item_decl.item_type

"true or false"
       if expr.kind == expr.simpleName :
          ident = expr.id
          if ident == "true" :
             expr.item_value = True
          elif ident == "false" :
             expr.item_value = False

if hasattr (expr.item_decl, "item_value") :
          expr.item_value = expr.item_decl.item_value

def on_field_expr (self, expr) :
       left = expr.left
       right = expr.simp_name
       right.item_name = right.id

decl = None
       if left.item_type != None :
          decl = getattr (left.item_type, "type_decl", None)
       elif left.item_decl != None :
          decl = left.item_decl # class name or enum type name
          if not isinstance (decl, Class) and not isinstance (decl, Enum) and not isinstance (decl, Typedef) :
             decl = None

if decl != None and getattr (decl, "item_dict", None) != None :
             right.item_decl = decl.item_dict.get (right.item_name)
             # if expr.item_decl == None :
             #    self.warning ("Unknown field: " + expr.item_name)
             expr.item_decl = right.item_decl
             if getattr (right.item_decl, "item_type", None) != None : # !?.
                expr.item_type = right.item_decl.item_type
             self.markUsage (right, right.item_decl)
       self.custom_field (expr)

def on_int_value (self, expr) :
       expr.item_type = self.intType
       text = expr.value
       if text.startswith ("0") :
          if text.startswith ("0x") :
             expr.item_value = int (text[2:], 16)
          elif text.startswith ("0b") :
             expr.item_value = int (text[2:], 2)
          elif text.startswith ("0o") :
             expr.item_value = int (text[2:], 8)
          elif text.startswith ("0q") :
             expr.item_value = int (text[2:], 8)
          elif len (text) > 1 :
             expr.item_value = int (text[1:], 8) # starting zero => octal
          else :
             expr.item_value = 0
       else:
          expr.item_value = int (text)

def on_real_value (self, expr) :
       expr.item_type = self.doubleType
       expr.item_value = float (expr.value)

def on_char_value (self, expr) :
       expr.item_type = self.charType
       expr.item_value = expr.value

def on_string_value (self, expr) :
       expr.item_type = self.stringType

text = expr.value
       for item in expr.items :
          text = text + item.value
       expr.item_value = text

def on_call_expr (self, expr) :
       self.custom_call (expr)

def on_binary_expr (self, expr) :
       if expr.kind in [expr.mulExp, expr.divExp, expr.modExp,
                        expr.addExp, expr.subExp,
                        expr.shlExp, expr.shrExp,
                        expr.bitAndExp, expr.bitOrExp, expr.bitXorExp ] :
          "result type"
          a = self.type_number (expr.left)
          b = self.type_number (expr.right)
          inx = a
          if b > inx :
             inx = b
          if inx == self.doubleInx :
             expr.item_type = self.doubleType
          if inx == self.floatInx :
             expr.item_type = self.floatType
          if inx == self.unsignedLongInx :
             expr.item_type = self.unsignedLongType
          if inx == self.longInx :
             expr.item_type = self.longType
          if inx == self.unsignedIntInx :
             expr.item_type = self.unsignedIntType
          if inx == self.intInx :
             expr.item_type = self.intType

self.custom_binary (expr, inx)

elif expr.kind in [expr.ltExp, expr.leExp, expr.gtExp, expr.geExp, expr.eqExp, expr.neExp,
                        expr.logAndExp, expr.logOrExp ] :
          expr.item_type = self.boolType
          self.custom_relation (expr)

elif expr.kind in [expr.assignExp] :
          self.custom_assign (expr)

self.binary_expr_value (expr)

# expression value

def get_expr_value (self, expr) :
       return getattr (expr, "item_value", None)

def binary_expr_value (self, expr) :
       value = None

if expr.kind in [ expr.addExp, expr.subExp, expr.mulExp, expr.divExp, expr.modExp,
                         expr.shlExp, expr.shrExp, expr.bitAndExp, expr.bitOrExp, expr.bitXorExp,
                         expr.ltExp, expr.gtExp, expr.leExp, expr.geExp, expr.eqExp, expr.neExp ] :
          left = self.get_expr_value (expr.left)
          right = self.get_expr_value (expr.right)
          if left != None and right != None :
             if expr.kind == expr.addExp : value = left + right
             if expr.kind == expr.subExp : value = left - right
             if expr.kind == expr.mulExp : value = left * right
             if expr.kind == expr.divExp : value = left / right
             if expr.kind == expr.modExp : value = left % right
             if expr.kind == expr.shlExp : value = left << right
             if expr.kind == expr.shrExp : value = left >> right

if expr.kind == expr.bitAndExp : value = left & right
             if expr.kind == expr.bitOrExp  : value = left | right
             if expr.kind == expr.bitXorExp : value = left ^ right

if expr.kind == expr.ltExp : value = left < right
             if expr.kind == expr.gtExp : value = left > right
             if expr.kind == expr.leExp : value = left <= right
             if expr.kind == expr.geExp : value = left >= right
             if expr.kind == expr.eqExp : value = left == right
             if expr.kind == expr.neExp : value = left != right

elif expr.kind == expr.logAndExp :
          left = self.get_expr_value (expr.left)
          if left != None :
             if left == False :
                value = False
             else :
                value = self.get_expr_value (expr.right)

elif expr.kind == expr.logOrExp :
          left = self.get_expr_value (expr.left)
          if left != None :
             if left == True :
                value = True
             else :
                value = self.get_expr_value (expr.right)

expr.item_value = value

# expression type

intInx = 1
   unsignedIntInx = 2
   longInx = 3
   unsignedLongInx = 4
   floatInx = 5
   doubleInx = 6
   unknownInx = 7

def init_types (self) :
       self.intType = SimpleType ()
       self.intType.type_int = True

self.unsignedIntType = SimpleType ()
       self.unsignedIntType.type_unsigned = True
       self.unsignedIntType.type_int = True

self.longType = SimpleType ()
       self.longType.type_long = True

self.unsignedLongType = SimpleType ()
       self.unsignedLongType.type_unsigned = True
       self.unsignedLongType.type_long = True

self.floatType = SimpleType ()
       self.floatType.type_float = True

self.doubleType = SimpleType ()
       self.doubleType.type_double = True

self.boolType = SimpleType ()
       self.boolType.type_bool = True

self.charType = SimpleType ()
       self.charType.type_char = True

# self.wcharType = SimpleType ()
       # self.wcharType.type_wchar = True

# self.voidType = SimpleType ()
       # self.voidType.type_void = True

self.stringType = NamedType ()
       self.stringType.type_name = "string" # !?

def type_number (self, expr) :
       inx = self.unknownInx
       type = expr.item_type
       if type != None:
          if isinstance (type, SimpleType) : # !?
             if type.type_double :
                inx = self.doubleInx
             elif type.type_float :
                inx = self.floatInx
             elif type.type_long :
                if type.type_unsigned :
                   inx = self.unsignedLongInx
                else :
                   inx = self.longInx
             elif type.type_int or type.type_short or type.type_wchar or type.type_char or type.type_bool :
                if type.type_unsigned :
                   inx = self.unsignedIntInx
                else :
                   inx = self.intInx
       return inx

# -----------------------------------------------------------------------

def on_declaration_list (self, decl_list) :
       if self.top_decl_list == None :
          self.top_decl_list = decl_list

# -----------------------------------------------------------------------

def custom_namespace (self, ns_decl) :
       pass

def custom_simple_item (self, simple_decl, simple_item) :
       pass

def custom_simple_declaration (self, simple_decl) :
       pass

def custom_simple_statement (self, stat) :
       pass

def custom_block_statement (self, stat) :
       pass

def custom_base_name (self, qual_name) :
       pass

def custom_relation (self, expr) :
       pass

def custom_binary (self, expr, inx) :
       pass

def custom_assign (self, expr) :
       pass

def custom_call (self, expr) :
       pass

def custom_field (self, expr) :
       pass

def custom_type_specifiers (self, type_spec, type) :
       pass

def custom_statement (self, target, stat) :
       pass

# --------------------------------------------------------------------------

class CmmQtCompiler (CmmCompiler) :

def __init__ (self) :
       super (CmmQtCompiler, self).__init__ ()

self.foreign_modules = { }
       self.foreign_types = { }

# -----------------------------------------------------------------------

# special scopes

def registerScope (self, top, name) :
       if name in top.registered_scopes :
          result = top.registered_scopes [name]
       else :
          result = Scope ()
          result.hidden_scope = True
          self.register (top, name, result)
       return result

def enter_unknown (self, top, name, qual_name) :
       scope = self.registerScope (top, "(unknown)")
       if name in scope.item_dict :
          unknown = scope.item_dict [name]
       else :
          unknown = Unknown ()
          unknown.item_name = name
          unknown.link_code (qual_name)
          self.enterIntoScope (scope, unknown)
          self.copy_location (unknown, qual_name)
          unknown.item_ink = findColor ("unknown")
       qual_name.item_decl = unknown

def enter_foreign (self, top, name, qual_name) :
       scope = self.registerScope (top, "(foreign)")
       # scope = top
       if name in scope.item_dict :
          result = scope.item_dict [name]
       else :
          result = Unknown ()
          result.item_name = name
          result.link_code (qual_name)
          self.enterIntoScope (scope, result)
          result.item_place = top # after enterIntoScope
          self.copy_location (result, qual_name)
          result.item_ink = findColor ("foreign")
       qual_name.item_decl = result

# -----------------------------------------------------------------------

def find_foreign_object (self, name) :
       result = None
       for module in self.foreign_modules :
           if result == None :
              result = getattr (module, name, None)
              # print ("FOUND", name, result)
       # if name.startswith ("QTable") :
       #    print ("FOUND", name, result)
       return result

def find_foreign_variable (self, var) :
       type = var.item_type

if isinstance (type, PointerType) :
          type = type.type_from
       if isinstance (type, NamedType) :
          name = type.type_name
          var.foreign_obj = self.find_foreign_object (name) # variable with Qt type

# -----------------------------------------------------------------------

# custom identifiers

def custom_base_name (self, qual_name) :
       if qual_name.item_decl == None and qual_name.kind == qual_name.simpleName :
          name = qual_name.id

"foreign identifiers (Qt field names)"
          inx = len (self.display) - 1
          while qual_name.item_decl == None and inx >= 0 :
             scope = self.display [inx]
             if scope.foreign_obj != None :
                if hasattr (scope.foreign_obj, name) :
                   self.enter_foreign (scope, name, qual_name)
                   # print ("QT item", name)
             inx = inx - 1

stop = False
          foreign = self.find_foreign_object (name) # variable with Qt type
          if foreign != None :
             # print ("FOREIGN", foreign.__name__)
             self.enter_foreign (self.global_scope, name, qual_name)
             if inspect.isclass (foreign) :
                qual_name.type_flag = True
             stop = True

if not stop :
             "unknown identifiers"
             inx = len (self.display) - 1
             while qual_name.item_decl == None and inx >= 0 :
                scope = self.display [inx]
                if scope.default_scope :
                   self.enter_unknown (scope, name, qual_name)
                   # print ("UNKNOWN item", name)
                inx = inx - 1

if qual_name.item_decl == None :
                self.enter_unknown (self.global_scope, name, qual_name)

def custom_open_class (self, cls) :
       base_list = cls.item_code.base_list
       if base_list != None :
          for item in base_list.items :
              if cls.foreign_obj == None :
                 name = item.from_cls.id
                 cls.foreign_obj = self.find_foreign_object (name) # class with one/first Qt super class

# -----------------------------------------------------------------------

# Qt assign

def custom_assign (self, expr) :
       var = expr.left.item_decl
       right = expr.right

if var != None : # !?
          self.find_foreign_variable (var)

name = var.item_name
          target_obj = var.item_place.foreign_obj

context = var.item_context
          if context.item_name == "(foreign)" : # !?
             foreign = context.item_context.foreign_obj
             if foreign != None :
                set_name = "set" + name.capitalize ()
                if hasattr (foreign, name) and hasattr (foreign, set_name) :
                   expr.alt_assign = set_name

if self.is_subtype (target_obj, "QTreeWidgetItem") :
             if name == "text":
                expr.alt_assign = "<text>"
             elif name == "icon" :
                expr.alt_assign = "<icon>"
             elif name == "foreground" :
                expr.alt_assign = "<foreground>"
             elif name == "background" :
                expr.alt_assign = "<background>"

else :
             if name == "icon" :
                expr.alt_assign = "<setIcon>"
             elif name == "shortcut" :
                expr.alt_assign = "<setShortcut>"

# -----------------------------------------------------------------------

# Qt field initialization

def find_type (self, name) :
       result = None
       if name in self.foreign_types :
          result = self.foreign_types [name]
       else :
          for module in self.foreign_modules :
              if result == None :
                 result = getattr (module, name, None)
          self.foreign_types [name] = result # store type or None
       return result

def is_subtype (self, obj, name) :
       type = self.find_type (name)
       result = obj != None and issubclass (obj, type)
       return result

def custom_simple_item (self, simple_decl, simple_item) :
       var = simple_item.item_ref

var.default_scope = True
       self.find_foreign_variable (var)

type = var.item_type
       type_name = ""
       if isinstance (type, PointerType) :
          type = type.type_from
       if getattr (type, "type_name", "") != "" :
          type_name = type.type_name

local_obj = var.foreign_obj

target_obj = None
       if var.item_place != None :
          target_obj = var.item_place.foreign_obj

if self.is_subtype (target_obj, "QMainWindow") :
          if self.is_subtype (local_obj, "QMenuBar") :
             var.alt_create = "<menuBar>"
          elif self.is_subtype (local_obj, "QToolBar") :
             var.alt_create = "<addToolBar>"
          elif self.is_subtype (local_obj, "QStatusBar") :
             var.alt_create = "<statusBar>"
          elif self.is_subtype (local_obj, "QLayout")  :
             var.alt_setup = "<layout>"
          else :
             var.alt_setup = "<setCentralWidget>"

if var.alt_create == "" :
          if self.is_subtype (local_obj, "QTreeWidgetItem") :
             var.alt_create = type_name
             var.alt_create_place = True
          elif self.is_subtype (local_obj, "QTableWidgetItem") :
             var.alt_create = type_name
          elif self.is_subtype (local_obj, "QWidget") :
             var.alt_create = type_name
             var.alt_create_owner = True
          elif self.is_subtype (local_obj, "QAction") :
             var.alt_create = type_name
             var.alt_create_owner = True
          elif self.is_subtype (local_obj, "QLayout") :
             var.alt_create = type_name
             var.alt_create_owner = True

# if self.is_subtype (target_obj, "QMainWindow") :
       #    if self.is_subtype (local_obj, "QMenuBar") :
       #       pass
       #    elif self.is_subtype (local_obj, "QToolBar") :
       #       pass
       #    elif self.is_subtype (local_obj, "QStatusBar") :
       #       pass
       # elif self.is_subtype (target_obj, "QLayout") :
       if self.is_subtype (target_obj, "QLayout") :
          if self.is_subtype (local_obj, "QLayout") :
             var.alt_setup = "addLayout"
          else :
             var.alt_setup = "addWidget"

if self.is_subtype (target_obj, "QMenuBar") and self.is_subtype (local_obj, "QMenu") :
          var.alt_setup = "addMenu"
       elif self.is_subtype (local_obj, "QAction") :
          var.alt_setup = "addAction"
       elif self.is_subtype (target_obj, "QToolBar") or self.is_subtype (target_obj, "QStatusBar"):
          var.alt_setup = "addWidget"
       elif self.is_subtype (target_obj, "QTabWidget") :
          var.alt_setup = "addTab"
          var.alt_setup_param = quoteString (var.item_name) # !?
       elif self.is_subtype (target_obj, "QTreeWidget") :
          var.alt_setup = "addTopLevelItem"

elif self.is_subtype (target_obj, "QWidget") and self.is_subtype (local_obj, "QWidget") :
          pass
       elif target_obj != None and self.is_subtype (local_obj, "QWidget") :
          var.alt_setup = "addWidget"

type = var.item_type
       if isinstance (type, SimpleType) :
           if type.type_bool :
              var.alt_create = "<false>"
           if type.type_char or type.type_wchar :
              var.alt_create = "<char_zero>"
           if type.type_short or type.type_int or type.type_long :
              var.alt_create = "<zero>"
           if type.type_float or type.type_double :
              var.alt_create = "<real_zero>"

if isinstance (type, NamedType) :
          if type.type_name == "string" :
              var.alt_create = "<empty_string>"

if var.alt_create == "" :
          var.alt_create = "<null>"

# -----------------------------------------------------------------------

"Qt connect"

def custom_block_statement (self, stat) :
       expr = stat.inner_expr
       if expr.kind == expr.callExp : # !?
          if expr.left.kind == expr.simpleName : # !?
             dcl = getattr (expr.left, "item_decl", None) # !?
             if dcl != None :
                foreign = dcl.item_context.foreign_obj
                cls = self.getClass ()
                if cls != None :
                   method = Method ()
                   method.name = "method" + str (len (cls.methods)+1)
                   method.body = stat.body
                   cls.methods.append (method)
                   expr.alt_connect = method.name
                   expr.alt_connect_dcl = dcl
                   expr.alt_connect_signal = expr.left.id

def getClass (self) :
       inx = len (self.display) - 1
       obj = None
       while inx > 0 and obj == None :
          tmp = self.display[inx]
          if isinstance (tmp, Class) :
             obj = tmp
          else :
             inx = inx - 1
       return obj

# --------------------------------------------------------------------------

class CmmCustomCompiler (CmmQtCompiler) :

def __init__ (self) :
       super (CmmCustomCompiler, self).__init__ ()

"options"
       self.skip_functions = False

"type scope"
       self.type_scope = self.registerScope (self.global_scope, "(type)")

"expr scope"
       self.expr_cnt = 0
       self.expr_scope = self.registerScope (self.global_scope, "(expr)")

"language extensions"
       self.attribute_modules = [ ]

# -----------------------------------------------------------------------

def custom_field (self, expr) :
       left = expr.left
       right = expr.simp_name

"artificial fields"
       if isinstance (left.item_decl, Class) :
          if right.item_decl == None and right.item_name == "fields" :
             "fields - list of variables declared in class"
             fields = [ ]
             for item in left.item_decl.item_list :
                 if isinstance (item, Variable) and not item.is_function :
                    fields.append (NoQuote (item.item_name))
             expr.item_value = fields

# -----------------------------------------------------------------------

# special scopes

def enter_type (self, type) :
       name = str (type)
       if name in self.type_scope.item_dict :
          decl = self.type_scope.item_dict [name]
          self.copy_style (type, decl)
       else :
          type.item_name = name
          self.enterIntoScope (self.type_scope, type)
          self.selectColor (type)

# -----------------------------------------------------------------------

# attributes

def custom_namespace (self, ns_decl) :
       "namespace_attributes"
       ns = ns_decl.item_ref
       for group in ns_decl.attr.items :
           for a in group.items :
               n = self.get_expr_name (a.attr_expr)
               if n == "compile_time" :
                  ns.attr_compile_time = True
                  ns.skip_code = True
               else :
                  self.error ("Unknown namespace attribute: " + n)

def custom_class (self, cls_decl) :
       "class attributes"
       cls = cls_decl.item_ref
       for group in cls_decl.attr.items :
           for a in group.items :
               n = self.get_expr_name (a.attr_expr)
               if n == "compile_time" :
                  cls.attr_compile_time = True
                  cls.skip_code = True
               else :
                  self.error ("Unknown class attribute: " + n)

def custom_simple_item (self, simple_decl, simple_item) :
       "invoke attribute"
       if self.no_decl_spec (simple_decl.decl_spec) :
          if not simple_decl.a_destructor :
             expr = simple_decl.type_spec
             if expr.kind == expr.simpleName : # !?
                dcl = expr.item_decl
                if dcl != None and isinstance (dcl, Variable):
                   if dcl.attr_compile_time :
                      if dcl.attr_field :
                         self.set_field (dcl.item_name)
                      else :
                         self.invoke_attribute (dcl.item_name)

decl = simple_item.decl # declarator
                   if decl.qual_name == None :
                      if len (decl.ptr_spec.items) == 0 :
                         if len (decl.ptr_spec.items) == 0 :
                            if len (decl.cont_spec.items) == 1 :
                               cont = decl.cont_spec.items [0]
                               if isinstance (cont, CmmFunctionSpecifier) :
                                  values = [ ]
                                  if not cont.cv_spec.cv_const :
                                     if not cont.cv_spec.cv_volatile :
                                        if cont.exception_spec == None :
                                           params = cont.parameters
                                           for param in params :
                                               if (param.decl != None or
                                                   param.dots or
                                                   param.item_value == None) :
                                                   self.error ("Invalid attribute value")
                                               values.append (param.item_value)
                                  if dcl.attr_field :
                                     self.set_field (dcl.item_name, values)
                                  else :
                                     self.invoke_attribute (dcl.item_name, values)
       "simple item attributes"
       var = simple_item.item_ref
       for g in simple_item.attr.items :
           for a in g.items :
              n = self.get_expr_name (a.attr_expr)
              if n == "compile_time" :
                 var.attr_compile_time = True
              elif n == "field" :
                 var.attr_compile_time = True
                 var.attr_field = True
              elif n == "context" :
                 var.attr_context = True
              else :
                 self.error ("Unknown attribute: " + n)
       if var.attr_compile_time :
          if not var.attr_field :
              self.check_attribute (simple_item)
          var.skip_code = True

"Qt assign / declaration"
       super (CmmCustomCompiler, self).custom_simple_item (simple_decl, simple_item)

def custom_simple_statement (self, stat) :
       expr = stat.inner_expr
       if expr.kind == expr.simpleName : # !?
          dcl = expr.item_decl
          if dcl != None and isinstance (dcl, Variable):
             if dcl.attr_compile_time :
                if dcl.attr_field :
                   self.set_field (dcl.item_name)
                else :
                   self.invoke_attribute (dcl.item_name)
       "Qt connect"
       super (CmmCustomCompiler, self).custom_simple_statement (stat)

def no_decl_spec (self, decl_spec) :
       return ( decl_spec == None or
                ( not decl_spec.a_inline and
                  not decl_spec.a_virtual and
                  not decl_spec.a_explicit and
                  not decl_spec.a_mutable and
                  not decl_spec.a_static and
                  not decl_spec.a_register ) )

def get_expr_name (self, expr) :
       return self.get_name (expr)

def getContext (self) :
       inx = len (self.display) - 1
       obj = None
       cont = True
       while inx > 0 and cont :
          obj = self.display[inx]
          if ( isinstance (obj, Namespace) or
               isinstance (obj, Enum) or
               isinstance (obj, Class) or
               isinstance (obj, Variable) ) :
             cont = False
          else :
             inx = inx - 1
       return obj

def set_field (self, name, value = True) :
       ctx = self.getContext ()
       setattr (ctx, name, value)
       ctx.item_tooltip = "field " + name
       self.info ("SET FIELD " + getattr (ctx, "item_name", "?") + "." + name + " = " + str (value))

def custom_call (self, expr) :
       left = expr.left
       if left.kind == left.simpleName : # !?

"attributes"
          dcl = left.item_decl
          if dcl != None and isinstance (dcl, Variable):

if dcl.attr_compile_time :
                expr.skip_code = True

name = dcl.item_name
                values = [ ]
                if dcl.attr_context :
                   values.append (expr)

inx = 0
                for param in expr.param_list.items :
                    inx = inx + 1
                    if dcl.attr_context : # !?
                       value = param
                    else :
                       if hasattr (param, "item_value") :
                          value = param.item_value
                       else :
                          value = None
                          self.error ("Unknown value of attribute parameter: " + name + " " + str (inx))
                    values.append (value)

self.invoke_attribute (name, values)

# -----------------------------------------------------------------------

def find_attribute (self, name) :
       result = None
       if hasattr (self, name) :
          result = getattr (self, name)
       if result == None :
          for module in self.attribute_modules :
              if result == None :
                 result = getattr (module, name, None)
       if result == None :
          self.error ("Missing attribute implementation: " + name)
       return result

def check_attribute (self, decl) :
       name = decl.item_ref.item_name
       self.find_attribute (name) # only check

def invoke_attribute (self, name, arg_list = [ ]) :
       obj = self.find_attribute (name)
       if obj != None :
          if callable (obj) :
             self.info ("INVOKE " + name)
             obj (*arg_list)

</code>

Edit summary

Note: By editing this page you agree to license your content under the following license: CC Attribution-Noncommercial-Share Alike 4.0 International