Returns the raw lines to be printed.
334948
def cmd_print(self):
        """"""
        if not self._valid_lines:
            return ''
        return '\n'.join([line.raw_line for line in self._valid_lines]) + '\n'
93232
def sourcelines(self):
        """"""
        # get sourcecode from loader or file
        source = None
        if self.loader is not None:
            try:
                if hasattr(self.loader, 'get_source'):
                    source = self.loader.get_source(self.module)
                elif hasattr(self.loader, 'get_source_by_code'):
                    source = self.loader.get_source_by_code(self.code)
            except Exception:
                # we munch the exception so that we don't cause troubles
                # if the loader is broken.
                pass

        if source is None:
            try:
                f = codecs.open(self.filename, 'r', 'utf-8')
            except IOError:
                return []
            try:
                source = f.read()
            finally:
                f.close()

        return source.splitlines()
168569
def writelines(self, lines):
        """"""
        self.make_dir()
        with open(self.path, "w") as f:
            return f.writelines(lines)
917887
def prettyprint(datastr):
    
    maxwidth = WPToolsQuery.MAXWIDTH
    rpad = WPToolsQuery.RPAD

    extent = maxwidth - (rpad + 2)
    for line in datastr:
        if len(line) >= maxwidth:
            line = line[:extent] + '...'
        utils.stderr(line)
676834
def as_lines(self):
        """"""

        out_lines = []
        for t,v in self.lines:

            # Make the output prettier
            if t == 'Section':
                out_lines.append('')

            out_lines.append('{}: {}'.format(t,v if v is not None else '') )

        return '\n'.join(out_lines)
545253
def print_line(s, bold=False, underline=False, blinking=False, color=None, bgcolor=None, end='\n'):
    
    s = get_line(s, bold=bold, underline=underline,
                 blinking=blinking, color=color, bgcolor=bgcolor)
    print(s, end=end)
433907
def get_raw(self):
        
        code_raw = self.code.get_raw()
        self.insns_size = (len(code_raw) // 2) + (len(code_raw) % 2)

        buff = bytearray()
        buff += pack("<H", self.registers_size) + \
                pack("<H", self.ins_size) + \
                pack("<H", self.outs_size) + \
                pack("<H", self.tries_size) + \
                pack("<I", self.debug_info_off) + \
                pack("<I", self.insns_size) + \
                code_raw

        if self.tries_size > 0:
            if (self.insns_size % 2 == 1):
                buff += pack("<H", self.padding)

            for i in self.tries:
                buff += i.get_raw()
            buff += self.handlers.get_raw()

        return buff
1075318
def print_line(line):
    
    sys.__stdout__.write("{}\n".format(line))
    sys.__stdout__.flush()
891407
def inline(self):
        """"""
        tp_lines, tp_decl = self.get_decl_pair()
        tp_lines = " ".join(tp_lines)
        if tp_decl is None:
            return tp_lines
        else:
            return "%s %s" % (tp_lines, tp_decl)
1106607
def get_raw(self):
        
        return [self.name, self.size, self.last_modified, self.location]
844798
def get_raw(self):
        
        buff = bytearray()
        buff += self.get_obj()
        for i in self.list:
            buff += i.get_raw()
        return buff
1174367
def dump(self, src, length=16, start=0, preffix=""):
        """"""
        FILTER = \
            "".join([(len(repr(chr(x)))==3) and chr(x) or '.' \
                for x in xrange(256)])

        result = list()

        for i in xrange(0, len(src), length):
            s           = src[i : i + length]
            hexa        = " ".join(["%02X" % ord(x) for x in s])
            printable   = s.translate(FILTER)

            result.append("%s%08X   %-*s   %s\n" % \
                (preffix, start + i, length * 3, hexa, printable))

        return ''.join(result)
1098267
def lines(self, code):
        """"""
        if isinstance(code, str):
            fix_indentation = self.fix_indentation
            if fix_indentation:
                code = fix_indentation(code)
            return self.append(code)
        else:
            return self.append(code)
403270
public List<LineString> lineStrings() {
        return positions().children().stream()
                .map(LineString::new)
                .collect(Collectors.toList());
    }
835478
def get_lines(handle, line):
    
    for i, l in enumerate(handle):
        if i == line:
            return l
183068
def toStr(self) :
		""""""
		s = [self.strLegend]
		for l in self.lines :
			s.append(l.toStr())
		return self.lineSeparator.join(s)
152099
def print_paths(self):
        """"""
        # Uses a list to get the order right
        ret = []
        for i in self._get_paths():
            if i not in ret:
                ret.append(i)
        return os.pathsep.join(ret)