def write_method_annotation(self, clif, method, writer, skip=False):
     
     prefix = util.namespace_prefix(clif)
     prefix += util.camelcase_to_underscore(clif.prefix).lower()
     
     section_name = prefix + "_" + method.name
     
     writer.writeln("/**")
     
     if section_name in self._sections:
         lines = self._sections[section_name]
         for line in lines:
             writer.writeln(line)
     else:
         if not skip:
             writer.writeln(" * %s: " % section_name)
             writer.writeln(" *")
             if method.scope == Scope.INSTANCE:
                 writer.writeln(" * @self: a #%s instance" % util.clifname(clif))
             for param in method.parameters:
                 writer.writeln(" * @%s: ..." % param.name)
             if method.result is not NULL:
                 writer.writeln(" *")
                 if hasattr(clif, "constructor"):
                     if method is clif.constructor:
                         writer.writeln(" * Return value: a new #%s instance" % util.clifname(clif))
                     else:
                         writer.writeln(" * Return value: ...")
                 else:
                     writer.writeln(" * Return value: ...")
         else:
             writer.writeln(" * %s: (skip)" % section_name)
             writer.writeln(" *")
                     
     writer.writeln(" */")
 def __init__(self, object):
     
     Writer.__init__(self)
     
     self._obj = object
     self._func_name_creator = FuncNameCreator()
     self._base_prefix = util.camelcase_to_underscore(self._obj.prefix).lower()
     
     self.annotations = Annotations()
    def __init__(self, clif):

        self._clif = clif
        self._prefix = self._clif.prefix
        self._prefix = util.camelcase_to_underscore(self._prefix).lower()
        package = self._clif.package
        while package:
            if package.name:
                self._prefix = package.name.lower() + "_" + self._prefix
            package = package.package
	def _basename(self, obj):
		
		res = util.camelcase_to_underscore(obj.name).lower()
		
		package = obj.package
		while package:
			if package.name:
				res = package.name.lower() + "_" + res
			package = package.package
			
		return res
 def file_basename(self, element):
     
     res = util.camelcase_to_underscore(element.name).lower()
     
     package = element.package
     while package:
         if package.name:
             res = package.name.lower() + "_" + res
         package = package.package
     
     return res
 def __init__(self, flags):
     
     Writer.__init__(self)
     
     self._flags = flags
     
     namespace = ""
     basename = util.camelcase_to_underscore(self._flags.name)
     
     package = self._flags.package
     while package:
         if package.name:
             namespace = package.name + "_" + namespace
         package = package.package
             
     self._vars = {
                   "FLAGS_ABS_NAME": namespace.upper() + basename.upper(),
                   "FlagsAbsName": self.typename(self._flags),
                   }
    def __init__(self, interface):

        ClassIntfWriter.__init__(self, interface)

        namespace = ""
        basename = util.camelcase_to_underscore(self._obj.name)

        package = self._obj.package
        while package:
            if package.name:
                namespace = package.name + "_" + namespace
            package = package.package

        self._vars = {
            "Interface": self._clifname(self._obj),
            "INTERFACE": self._clifname(self._obj).upper(),
            "NAMESPACE": namespace.upper(),
            "BASENAME": basename.upper(),
            "prefix": namespace.lower() + self._base_prefix,
        }
 def __init__(self, enum):
     
     Writer.__init__(self)
     
     self._enum = enum
     
     namespace = ""
     basename = util.camelcase_to_underscore(self._enum.name)
     
     package = self._enum.package
     while package:
         if package.name:
             namespace = package.name + "_" + namespace
         package = package.package
             
     self._vars = {
                   "NAMESPACE": namespace.upper(),
                   "BASENAME": basename.upper(),
                   "ENUM_ABS_NAME": namespace.upper() + basename.upper(),
                   "EnumAbsName": self.typename(self._enum),
                   "prefix": namespace.lower() + basename.lower()
                   }
 def __init__(self, error_domain):
     
     Writer.__init__(self)
     
     self._error = error_domain
     
     namespace = ""
     basename = util.camelcase_to_underscore(self._error.name)
     error_domain_name = self._error.name
     
     package = self._error.package
     while package:
         if package.name:
             namespace = package.name + "_" + namespace
             error_domain_name = package.name.capitalize() + error_domain_name
         package = package.package
             
     self._vars = {
                   "ERROR_DOMAIN_NAME": namespace.upper() + basename.upper(),
                   "error_domain_name": namespace.lower() + basename.lower(),
                   "ErrorDomainName": error_domain_name,
                   }
Example #10
0
 def to_underscore(self, name):
     
     return util.camelcase_to_underscore(name)