diff options
| author | Kenneth Reitz <me@kennethreitz.com> | 2010-09-11 23:08:31 -0400 |
|---|---|---|
| committer | Kenneth Reitz <me@kennethreitz.com> | 2010-09-11 23:08:31 -0400 |
| commit | da4f2013f1e8b05d937369c1867a25ed79ff4faf (patch) | |
| tree | 0f12eb90da2ea4f538574128b5ed0181d6abd08b | |
| parent | 310400af5b3696be2cfd2f0816f7f621d945033f (diff) | |
| download | tablib-da4f2013f1e8b05d937369c1867a25ed79ff4faf.tar.gz | |
Unvendorized packages.
52 files changed, 0 insertions, 13167 deletions
diff --git a/tablib/packages/xlwt/BIFFRecords.py b/tablib/packages/xlwt/BIFFRecords.py deleted file mode 100644 index 632c64e..0000000 --- a/tablib/packages/xlwt/BIFFRecords.py +++ /dev/null @@ -1,2393 +0,0 @@ -# -*- coding: cp1252 -*-
-from struct import pack
-from UnicodeUtils import upack1, upack2
-import sys
-
-class SharedStringTable(object):
- _SST_ID = 0x00FC
- _CONTINUE_ID = 0x003C
-
- def __init__(self, encoding):
- self.encoding = encoding
- self._str_indexes = {}
- self._tally = []
- self._add_calls = 0
- # Following 3 attrs are used for temporary storage in the
- # get_biff_record() method and methods called by it. The pseudo-
- # initialisation here is for documentation purposes only.
- self._sst_record = None
- self._continues = None
- self._current_piece = None
-
- def add_str(self, s):
- if self.encoding != 'ascii' and not isinstance(s, unicode):
- s = unicode(s, self.encoding)
- self._add_calls += 1
- if s not in self._str_indexes:
- idx = len(self._str_indexes)
- self._str_indexes[s] = idx
- self._tally.append(1)
- else:
- idx = self._str_indexes[s]
- self._tally[idx] += 1
- return idx
-
- def del_str(self, idx):
- # This is called when we are replacing the contents of a string cell.
- assert self._tally[idx] > 0
- self._tally[idx] -= 1
- self._add_calls -= 1
-
- def str_index(self, s):
- return self._str_indexes[s]
-
- def get_biff_record(self):
- self._sst_record = ''
- self._continues = [None, None]
- self._current_piece = pack('<II', 0, 0)
- data = [(idx, s) for s, idx in self._str_indexes.iteritems()]
- data.sort() # in index order
- for idx, s in data:
- if self._tally[idx] == 0:
- s = u''
- self._add_to_sst(s)
- del data
- self._new_piece()
- self._continues[0] = pack('<2HII', self._SST_ID, len(self._sst_record), self._add_calls, len(self._str_indexes))
- self._continues[1] = self._sst_record[8:]
- self._sst_record = None
- self._current_piece = None
- result = ''.join(self._continues)
- self._continues = None
- return result
-
-
- def _add_to_sst(self, s):
- u_str = upack2(s, self.encoding)
-
- is_unicode_str = u_str[2] == '\x01'
- if is_unicode_str:
- atom_len = 5 # 2 byte -- len,
- # 1 byte -- options,
- # 2 byte -- 1st sym
- else:
- atom_len = 4 # 2 byte -- len,
- # 1 byte -- options,
- # 1 byte -- 1st sym
-
- self._save_atom(u_str[0:atom_len])
- self._save_splitted(u_str[atom_len:], is_unicode_str)
-
- def _new_piece(self):
- if self._sst_record == '':
- self._sst_record = self._current_piece
- else:
- curr_piece_len = len(self._current_piece)
- self._continues.append(pack('<2H%ds'%curr_piece_len, self._CONTINUE_ID, curr_piece_len, self._current_piece))
- self._current_piece = ''
-
- def _save_atom(self, s):
- atom_len = len(s)
- free_space = 0x2020 - len(self._current_piece)
- if free_space < atom_len:
- self._new_piece()
- self._current_piece += s
-
- def _save_splitted(self, s, is_unicode_str):
- i = 0
- str_len = len(s)
- while i < str_len:
- piece_len = len(self._current_piece)
- free_space = 0x2020 - piece_len
- tail_len = str_len - i
- need_more_space = free_space < tail_len
-
- if not need_more_space:
- atom_len = tail_len
- else:
- if is_unicode_str:
- atom_len = free_space & 0xFFFE
- else:
- atom_len = free_space
-
- self._current_piece += s[i:i+atom_len]
-
- if need_more_space:
- self._new_piece()
- if is_unicode_str:
- self._current_piece += '\x01'
- else:
- self._current_piece += '\x00'
-
- i += atom_len
-
-
-class BiffRecord(object):
-
- _rec_data = '' # class attribute; child classes need to set this.
-
- # Sheer waste.
- # def __init__(self):
- # self._rec_data = ''
-
- def get_rec_id(self):
- return _REC_ID
-
- def get_rec_header(self):
- return pack('<2H', self._REC_ID, len(self._rec_data))
-
- # Not over-ridden by any child classes, never called (except by "get"; see below).
- # def get_rec_data(self):
- # return self._rec_data
-
- def get(self):
- # data = self.get_rec_data()
- data = self._rec_data
-
- if len(data) > 0x2020: # limit for BIFF7/8
- chunks = []
- pos = 0
- while pos < len(data):
- chunk_pos = pos + 0x2020
- chunk = data[pos:chunk_pos]
- chunks.append(chunk)
- pos = chunk_pos
- continues = pack('<2H', self._REC_ID, len(chunks[0])) + chunks[0]
- for chunk in chunks[1:]:
- continues += pack('<2H%ds'%len(chunk), 0x003C, len(chunk), chunk)
- # 0x003C -- CONTINUE record id
- return continues
- else:
- return self.get_rec_header() + data
-
-
-class Biff8BOFRecord(BiffRecord):
- """
- Offset Size Contents
- 0 2 Version, contains 0600H for BIFF8 and BIFF8X
- 2 2 Type of the following data:
- 0005H = Workbook globals
- 0006H = Visual Basic module
- 0010H = Worksheet
- 0020H = Chart
- 0040H = Macro sheet
- 0100H = Workspace file
- 4 2 Build identifier
- 6 2 Build year
- 8 4 File history flags
- 12 4 Lowest Excel version that can read all records in this file
- """
- _REC_ID = 0x0809
- # stream types
- BOOK_GLOBAL = 0x0005
- VB_MODULE = 0x0006
- WORKSHEET = 0x0010
- CHART = 0x0020
- MACROSHEET = 0x0040
- WORKSPACE = 0x0100
-
- def __init__(self, rec_type):
- version = 0x0600
- build = 0x0DBB
- year = 0x07CC
- file_hist_flags = 0x00L
- ver_can_read = 0x06L
-
- self._rec_data = pack('<4H2I', version, rec_type, build, year, file_hist_flags, ver_can_read)
-
-
-class InteraceHdrRecord(BiffRecord):
- _REC_ID = 0x00E1
-
- def __init__(self):
- self._rec_data = pack('BB', 0xB0, 0x04)
-
-
-class InteraceEndRecord(BiffRecord):
- _REC_ID = 0x00E2
-
- def __init__(self):
- self._rec_data = ''
-
-
-class MMSRecord(BiffRecord):
- _REC_ID = 0x00C1
-
- def __init__(self):
- self._rec_data = pack('<H', 0x00)
-
-
-class WriteAccessRecord(BiffRecord):
- """
- This record is part of the file protection. It contains the name of the
- user that has saved the file. The user name is always stored as an
- equal-sized string. All unused characters after the name are filled
- with space characters. It is not required to write the mentioned string
- length. Every other length will be accepted too.
- """
- _REC_ID = 0x005C
-
- def __init__(self, owner):
- uowner = owner[0:0x30]
- uowner_len = len(uowner)
- self._rec_data = pack('%ds%ds' % (uowner_len, 0x70 - uowner_len), uowner, ' '*(0x70 - uowner_len))
-
-
-class DSFRecord(BiffRecord):
- """
- This record specifies if the file contains an additional BIFF5/BIFF7
- workbook stream.
- Record DSF, BIFF8:
- Offset Size Contents
- 0 2 0 = Only the BIFF8 Workbook stream is present
- 1 = Additional BIFF5/BIFF7 Book stream is in the file
- A double stream file can be read by Excel 5.0 and Excel 95, and still
- contains all new features added to BIFF8 (which are left out in the
- BIFF5/BIFF7 Book stream).
- """
- _REC_ID = 0x0161
-
- def __init__(self):
- self._rec_data = pack('<H', 0x00)
-
-
-class TabIDRecord(BiffRecord):
- _REC_ID = 0x013D
-
- def __init__(self, sheetcount):
- for i in range(sheetcount):
- self._rec_data += pack('<H', i+1)
-
-
-class FnGroupCountRecord(BiffRecord):
- _REC_ID = 0x009C
-
- def __init__(self):
- self._rec_data = pack('BB', 0x0E, 0x00)
-
-
-class WindowProtectRecord(BiffRecord):
- """
- This record is part of the worksheet/workbook protection. It determines
- whether the window configuration of this document is protected. Window
- protection is not active, if this record is omitted.
- """
- _REC_ID = 0x0019
-
- def __init__(self, wndprotect):
- self._rec_data = pack('<H', wndprotect)
-
-
-class ObjectProtectRecord(BiffRecord):
- """
- This record is part of the worksheet/workbook protection.
- It determines whether the objects of the current sheet are protected.
- Object protection is not active, if this record is omitted.
- """
- _REC_ID = 0x0063
-
-
- def __init__(self, objprotect):
- self._rec_data = pack('<H', objprotect)
-
-
-class ScenProtectRecord(BiffRecord):
- """
- This record is part of the worksheet/workbook protection. It
- determines whether the scenarios of the current sheet are protected.
- Scenario protection is not active, if this record is omitted.
- """
- _REC_ID = 0x00DD
-
-
- def __init__(self, scenprotect):
- self._rec_data = pack('<H', scenprotect)
-
-
-class ProtectRecord(BiffRecord):
- """
- This record is part of the worksheet/workbook protection. It specifies
- whether a worksheet or a workbook is protected against modification.
- Protection is not active, if this record is omitted.
- """
-
- _REC_ID = 0x0012
-
- def __init__(self, protect):
- self._rec_data = pack('<H', protect)
-
-
-class PasswordRecord(BiffRecord):
- """
- This record is part of the worksheet/workbook protection. It
- stores a 16-bit hash value, calculated from the worksheet or workbook
- protection password.
- """
- _REC_ID = 0x0013
- def passwd_hash(self, plaintext):
- """
- Based on the algorithm provided by Daniel Rentz of OpenOffice.
- """
- if plaintext == "":
- return 0
-
- passwd_hash = 0x0000
- for i, char in enumerate(plaintext):
- c = ord(char) << (i + 1)
- low_15 = c & 0x7fff
- high_15 = c & 0x7fff << 15
- high_15 = high_15 >> 15
- c = low_15 | high_15
- passwd_hash ^= c
- passwd_hash ^= len(plaintext)
- passwd_hash ^= 0xCE4B
- return passwd_hash
-
- def __init__(self, passwd = ""):
- self._rec_data = pack('<H', self.passwd_hash(passwd))
-
-
-class Prot4RevRecord(BiffRecord):
- _REC_ID = 0x01AF
-
- def __init__(self):
- self._rec_data = pack('<H', 0x00)
-
-
-class Prot4RevPassRecord(BiffRecord):
- _REC_ID = 0x01BC
-
- def __init__(self):
- self._rec_data = pack('<H', 0x00)
-
-
-class BackupRecord(BiffRecord):
- """
- This record contains a Boolean value determining whether Excel makes
- a backup of the file while saving.
- """
- _REC_ID = 0x0040
-
- def __init__(self, backup):
- self._rec_data = pack('<H', backup)
-
-class HideObjRecord(BiffRecord):
- """
- This record specifies whether and how to show objects in the workbook.
-
- Record HIDEOBJ, BIFF3-BIFF8:
- Offset Size Contents
- 0 2 Viewing mode for objects:
- 0 = Show all objects
- 1 = Show placeholders
- 2 = Do not show objects
- """
- _REC_ID = 0x008D
-
- def __init__(self):
- self._rec_data = pack('<H', 0x00)
-
-
-
-class RefreshAllRecord(BiffRecord):
- """
- """
-
- _REC_ID = 0x01B7
-
- def __init__(self):
- self._rec_data = pack('<H', 0x00)
-
-
-class BookBoolRecord(BiffRecord):
- """
- This record contains a Boolean value determining whether to save values
- linked from external workbooks (CRN records and XCT records). In BIFF3
- and BIFF4 this option is stored in the WSBOOL record.
-
- Record BOOKBOOL, BIFF5-BIFF8:
-
- Offset Size Contents
- 0 2 0 = Save external linked values;
- 1 = Do not save external linked values
- """
-
- _REC_ID = 0x00DA
-
- def __init__(self):
- self._rec_data = pack('<H', 0x00)
-
-
-class CountryRecord(BiffRecord):
- """
- This record stores two Windows country identifiers. The first
- represents the user interface language of the Excel version that has
- saved the file, and the second represents the system regional settings
- at the time the file was saved.
-
- Record COUNTRY, BIFF3-BIFF8:
-
- Offset Size Contents
- 0 2 Windows country identifier of the user interface language of Excel
- 2 2 Windows country identifier of the system regional settings
-
- The following table shows most of the used country identifiers. Most
- of these identifiers are equal to the international country calling
- codes.
-
- 1 USA
- 2 Canada
- 7 Russia
- """
-
- _REC_ID = 0x008C
-
- def __init__(self, ui_id, sys_settings_id):
- self._rec_data = pack('<2H', ui_id, sys_settings_id)
-
-
-class UseSelfsRecord(BiffRecord):
- """
- This record specifies if the formulas in the workbook can use natural
- language formulas. This type of formula can refer to cells by its
- content or the content of the column or row header cell.
-
- Record USESELFS, BIFF8:
-
- Offset Size Contents
- 0 2 0 = Do not use natural language formulas
- 1 = Use natural language formulas
-
- """
-
- _REC_ID = 0x0160
-
- def __init__(self):
- self._rec_data = pack('<H', 0x01)
-
-
-class EOFRecord(BiffRecord):
- _REC_ID = 0x000A
-
- def __init__(self):
- self._rec_data = ''
-
-
-class DateModeRecord(BiffRecord):
- """
- This record specifies the base date for displaying date values. All
- dates are stored as count of days past this base date. In BIFF2-BIFF4
- this record is part of the Calculation Settings Block.
- In BIFF5-BIFF8 it is stored in the Workbook Globals Substream.
-
- Record DATEMODE, BIFF2-BIFF8:
-
- Offset Size Contents
- 0 2 0 = Base is 1899-Dec-31 (the cell = 1 represents 1900-Jan-01)
- 1 = Base is 1904-Jan-01 (the cell = 1 represents 1904-Jan-02)
- """
- _REC_ID = 0x0022
-
- def __init__(self, from1904):
- if from1904:
- self._rec_data = pack('<H', 1)
- else:
- self._rec_data = pack('<H', 0)
-
-
-class PrecisionRecord(BiffRecord):
- """
- This record stores if formulas use the real cell values for calculation
- or the values displayed on the screen. In BIFF2- BIFF4 this record
- is part of the Calculation Settings Block. In BIFF5-BIFF8 it is stored
- in the Workbook Globals Substream.
-
- Record PRECISION, BIFF2-BIFF8:
-
- Offset Size Contents
- 0 2 0 = Use displayed values;
- 1 = Use real cell values
- """
- _REC_ID = 0x000E
-
- def __init__(self, use_real_values):
- if use_real_values:
- self._rec_data = pack('<H', 1)
- else:
- self._rec_data = pack('<H', 0)
-
-
-class CodepageBiff8Record(BiffRecord):
- """
- This record stores the text encoding used to write byte strings, stored
- as MS Windows code page identifier. The CODEPAGE record in BIFF8 always
- contains the code page 1200 (UTF-16). Therefore it is not
- possible to obtain the encoding used for a protection password (it is
- not UTF-16).
-
- Record CODEPAGE, BIFF2-BIFF8:
-
- Offset Size Contents
- 0 2 Code page identifier used for byte string text encoding:
- 016FH = 367 = ASCII
- 01B5H = 437 = IBM PC CP-437 (US)
- 02D0H = 720 = IBM PC CP-720 (OEM Arabic)
- 02E1H = 737 = IBM PC CP-737 (Greek)
- 0307H = 775 = IBM PC CP-775 (Baltic)
- 0352H = 850 = IBM PC CP-850 (Latin I)
- 0354H = 852 = IBM PC CP-852 (Latin II (Central European))
- 0357H = 855 = IBM PC CP-855 (Cyrillic)
- 0359H = 857 = IBM PC CP-857 (Turkish)
- 035AH = 858 = IBM PC CP-858 (Multilingual Latin I with Euro)
- 035CH = 860 = IBM PC CP-860 (Portuguese)
- 035DH = 861 = IBM PC CP-861 (Icelandic)
- 035EH = 862 = IBM PC CP-862 (Hebrew)
- 035FH = 863 = IBM PC CP-863 (Canadian (French))
- 0360H = 864 = IBM PC CP-864 (Arabic)
- 0361H = 865 = IBM PC CP-865 (Nordic)
- 0362H = 866 = IBM PC CP-866 (Cyrillic (Russian))
- 0365H = 869 = IBM PC CP-869 (Greek (Modern))
- 036AH = 874 = Windows CP-874 (Thai)
- 03A4H = 932 = Windows CP-932 (Japanese Shift-JIS)
- 03A8H = 936 = Windows CP-936 (Chinese Simplified GBK)
- 03B5H = 949 = Windows CP-949 (Korean (Wansung))
- 03B6H = 950 = Windows CP-950 (Chinese Traditional BIG5)
- 04B0H = 1200 = UTF-16 (BIFF8)
- 04E2H = 1250 = Windows CP-1250 (Latin II) (Central European)
- 04E3H = 1251 = Windows CP-1251 (Cyrillic)
- 04E4H = 1252 = Windows CP-1252 (Latin I) (BIFF4-BIFF7)
- 04E5H = 1253 = Windows CP-1253 (Greek)
- 04E6H = 1254 = Windows CP-1254 (Turkish)
- 04E7H = 1255 = Windows CP-1255 (Hebrew)
- 04E8H = 1256 = Windows CP-1256 (Arabic)
- 04E9H = 1257 = Windows CP-1257 (Baltic)
- 04EAH = 1258 = Windows CP-1258 (Vietnamese)
- 0551H = 1361 = Windows CP-1361 (Korean (Johab))
- 2710H = 10000 = Apple Roman
- 8000H = 32768 = Apple Roman
- 8001H = 32769 = Windows CP-1252 (Latin I) (BIFF2-BIFF3)
- """
- _REC_ID = 0x0042
- UTF_16 = 0x04B0
-
- def __init__(self):
- self._rec_data = pack('<H', self.UTF_16)
-
-class Window1Record(BiffRecord):
- """
- Offset Size Contents
- 0 2 Horizontal position of the document window (in twips = 1/20 of a point)
- 2 2 Vertical position of the document window (in twips = 1/20 of a point)
- 4 2 Width of the document window (in twips = 1/20 of a point)
- 6 2 Height of the document window (in twips = 1/20 of a point)
- 8 2 Option flags:
- Bits Mask Contents
- 0 0001H 0 = Window is visible 1 = Window is hidden
- 1 0002H 0 = Window is open 1 = Window is minimised
- 3 0008H 0 = Horizontal scroll bar hidden 1 = Horizontal scroll bar visible
- 4 0010H 0 = Vertical scroll bar hidden 1 = Vertical scroll bar visible
- 5 0020H 0 = Worksheet tab bar hidden 1 = Worksheet tab bar visible
- 10 2 Index to active (displayed) worksheet
- 12 2 Index of first visible tab in the worksheet tab bar
- 14 2 Number of selected worksheets (highlighted in the worksheet tab bar)
- 16 2 Width of worksheet tab bar (in 1/1000 of window width). The remaining space is used by the
- horizontal scrollbar.
- """
- _REC_ID = 0x003D
- # flags
-
- def __init__(self,
- hpos_twips, vpos_twips,
- width_twips, height_twips,
- flags,
- active_sheet,
- first_tab_index, selected_tabs, tab_width):
- self._rec_data = pack('<9H', hpos_twips, vpos_twips,
- width_twips, height_twips,
- flags,
- active_sheet,
- first_tab_index, selected_tabs, tab_width)
-
-class FontRecord(BiffRecord):
- """
- WARNING
- The font with index 4 is omitted in all BIFF versions.
- This means the first four fonts have zero-based indexes, and
- the fifth font and all following fonts are referenced with one-based
- indexes.
-
- Offset Size Contents
- 0 2 Height of the font (in twips = 1/20 of a point)
- 2 2 Option flags:
- Bit Mask Contents
- 0 0001H 1 = Characters are bold (redundant, see below)
- 1 0002H 1 = Characters are italic
- 2 0004H 1 = Characters are underlined (redundant, see below)
- 3 0008H 1 = Characters are struck out
- 0010H 1 = Outline
- 0020H 1 = Shadow
- 4 2 Colour index
- 6 2 Font weight (100-1000).
- Standard values are 0190H (400) for normal text and 02BCH
- (700) for bold text.
- 8 2 Escapement type:
- 0000H = None
- 0001H = Superscript
- 0002H = Subscript
- 10 1 Underline type:
- 00H = None
- 01H = Single
- 21H = Single accounting
- 02H = Double
- 22H = Double accounting
- 11 1 Font family:
- 00H = None (unknown or don't care)
- 01H = Roman (variable width, serifed)
- 02H = Swiss (variable width, sans-serifed)
- 03H = Modern (fixed width, serifed or sans-serifed)
- 04H = Script (cursive)
- 05H = Decorative (specialised, i.e. Old English, Fraktur)
- 12 1 Character set:
- 00H = 0 = ANSI Latin
- 01H = 1 = System default
- 02H = 2 = Symbol
- 4DH = 77 = Apple Roman
- 80H = 128 = ANSI Japanese Shift-JIS
- 81H = 129 = ANSI Korean (Hangul)
- 82H = 130 = ANSI Korean (Johab)
- 86H = 134 = ANSI Chinese Simplified GBK
- 88H = 136 = ANSI Chinese Traditional BIG5
- A1H = 161 = ANSI Greek
- A2H = 162 = ANSI Turkish
- A3H = 163 = ANSI Vietnamese
- B1H = 177 = ANSI Hebrew
- B2H = 178 = ANSI Arabic
- BAH = 186 = ANSI Baltic
- CCH = 204 = ANSI Cyrillic
- DEH = 222 = ANSI Thai
- EEH = 238 = ANSI Latin II (Central European)
- FFH = 255 = OEM Latin I
- 13 1 Not used
- 14 var. Font name:
- BIFF5/BIFF7: Byte string, 8-bit string length
- BIFF8: Unicode string, 8-bit string length
- The boldness and underline flags are still set in the options field,
- but not used on reading the font. Font weight and underline type
- are specified in separate fields instead.
- """
- _REC_ID = 0x0031
-
- def __init__(self,
- height, options, colour_index, weight, escapement,
- underline, family, charset,
- name):
- uname = upack1(name)
- uname_len = len(uname)
-
- self._rec_data = pack('<5H4B%ds' % uname_len, height, options, colour_index, weight, escapement,
- underline, family, charset, 0x00,
- uname)
-
-class NumberFormatRecord(BiffRecord):
- """
- Record FORMAT, BIFF8:
- Offset Size Contents
- 0 2 Format index used in other records
- 2 var. Number format string (Unicode string, 16-bit string length)
-
- From BIFF5 on, the built-in number formats will be omitted. The built-in
- formats are dependent on the current regional settings of the operating
- system. The following table shows which number formats are used by default
- in a US-English environment. All indexes from 0 to 163 are reserved for
- built-in formats. The first user-defined format starts at 164.
-
- The built-in number formats, BIFF5-BIFF8
-
- Index Type Format string
- 0 General General
- 1 Decimal 0
- 2 Decimal 0.00
- 3 Decimal #,##0
- 4 Decimal #,##0.00
- 5 Currency "$"#,##0_);("$"#,##
- 6 Currency "$"#,##0_);[Red]("$"#,##
- 7 Currency "$"#,##0.00_);("$"#,##
- 8 Currency "$"#,##0.00_);[Red]("$"#,##
- 9 Percent 0%
- 10 Percent 0.00%
- 11 Scientific 0.00E+00
- 12 Fraction # ?/?
- 13 Fraction # ??/??
- 14 Date M/D/YY
- 15 Date D-MMM-YY
- 16 Date D-MMM
- 17 Date MMM-YY
- 18 Time h:mm AM/PM
- 19 Time h:mm:ss AM/PM
- 20 Time h:mm
- 21 Time h:mm:ss
- 22 Date/Time M/D/YY h:mm
- 37 Account _(#,##0_);(#,##0)
- 38 Account _(#,##0_);[Red](#,##0)
- 39 Account _(#,##0.00_);(#,##0.00)
- 40 Account _(#,##0.00_);[Red](#,##0.00)
- 41 Currency _("$"* #,##0_);_("$"* (#,##0);_("$"* "-"_);_(@_)
- 42 Currency _(* #,##0_);_(* (#,##0);_(* "-"_);_(@_)
- 43 Currency _("$"* #,##0.00_);_("$"* (#,##0.00);_("$"* "-"??_);_(@_)
- 44 Currency _(* #,##0.00_);_(* (#,##0.00);_(* "-"??_);_(@_)
- 45 Time mm:ss
- 46 Time [h]:mm:ss
- 47 Time mm:ss.0
- 48 Scientific ##0.0E+0
- 49 Text @
- """
- _REC_ID = 0x041E
-
- def __init__(self, idx, fmtstr):
- ufmtstr = upack2(fmtstr)
- ufmtstr_len = len(ufmtstr)
-
- self._rec_data = pack('<H%ds' % ufmtstr_len, idx, ufmtstr)
-
-
-class XFRecord(BiffRecord):
- """
- XF Substructures
- -------------------------------------------------------------------------
- XF_TYPE_PROT XF Type and Cell Protection (3 Bits), BIFF3-BIFF8
- These 3 bits are part of a specific data byte.
- Bit Mask Contents
- 0 01H 1 = Cell is locked
- 1 02H 1 = Formula is hidden
- 2 04H 0 = Cell XF; 1 = Style XF
-
- XF_USED_ATTRIB Attributes Used from Parent Style XF (6 Bits),
- BIFF3-BIFF8 Each bit describes the validity of a specific group
- of attributes. In cell XFs a cleared bit means the attributes of the
- parent style XF are used (but only if the attributes are valid there),
- a set bit means the attributes of this XF are used. In style XFs
- a cleared bit means the attribute setting is valid, a set bit means the
- attribute should be ignored.
- Bit Mask Contents
- 0 01H Flag for number format
- 1 02H Flag for font
- 2 04H Flag for horizontal and vertical alignment, text wrap, indentation, orientation, rotation, and
- text direction
- 3 08H Flag for border lines
- 4 10H Flag for background area style
- 5 20H Flag for cell protection (cell locked and formula hidden)
-
- XF_HOR_ALIGN Horizontal Alignment (3 Bits), BIFF2-BIFF8 The horizontal
- alignment consists of 3 bits and is part of a specific data byte.
- Value Horizontal alignment
- 00H General
- 01H Left
- 02H Centred
- 03H Right
- 04H Filled
- 05H Justified (BIFF4-BIFF8X)
- 06H Centred across selection (BIFF4-BIFF8X)
- 07H Distributed (BIFF8X)
-
- XF_VERT_ALIGN Vertical Alignment (2 or 3 Bits), BIFF4-BIFF8
- The vertical alignment consists of 2 bits (BIFF4) or 3 bits (BIFF5-BIFF8)
- and is part of a specific data byte. Vertical alignment is not available
- in BIFF2 and BIFF3.
- Value Vertical alignment
- 00H Top
- 01H Centred
- 02H Bottom
- 03H Justified (BIFF5-BIFF8X)
- 04H Distributed (BIFF8X)
-
- XF_ORIENTATION Text Orientation (2 Bits), BIFF4-BIFF7 In the BIFF
- versions BIFF4-BIFF7, text can be rotated in steps of 90 degrees
- or stacked. The orientation mode consists of 2 bits and is part of
- a specific data byte. In BIFF8 a rotation angle occurs instead of these
- flags.
- Value Text orientation
- 00H Not rotated
- 01H Letters are stacked top-to-bottom, but not rotated
- 02H Text is rotated 90 degrees counterclockwise
- 03H Text is rotated 90 degrees clockwise
-
- XF_ROTATION Text Rotation Angle (1 Byte), BIFF8
- Value Text rotation
- 0 Not rotated
- 1-90 1 to 90 degrees counterclockwise
- 91-180 1 to 90 degrees clockwise
- 255 Letters are stacked top-to-bottom, but not rotated
-
- XF_BORDER_34 Cell Border Style (4 Bytes), BIFF3-BIFF4 Cell borders
- contain a line style and a line colour for each line of the border.
- Bit Mask Contents
- 2-0 00000007H Top line style
- 7-3 000000F8H Colour index for top line colour
- 10-8 00000700H Left line style
- 15-11 0000F800H Colour index for left line colour
- 18-16 00070000H Bottom line style
- 23-19 00F80000H Colour index for bottom line colour
- 26-24 07000000H Right line style
- 31-27 F8000000H Colour index for right line colour
-
- XF_AREA_34 Cell Background Area Style (2 Bytes), BIFF3-BIFF4 A cell
- background area style contains an area pattern and a foreground and
- background colour.
- Bit Mask Contents
- 5-0 003FH Fill pattern
- 10-6 07C0H Colour index for pattern colour
- 15-11 F800H Colour index for pattern background
- ---------------------------------------------------------------------------------------------
- Record XF, BIFF8:
- Offset Size Contents
- 0 2 Index to FONT record
- 2 2 Index to FORMAT record
- 4 2 Bit Mask Contents
- 2-0 0007H XF_TYPE_PROT . XF type, cell protection (see above)
- 15-4 FFF0H Index to parent style XF (always FFFH in style XFs)
- 6 1 Bit Mask Contents
- 2-0 07H XF_HOR_ALIGN . Horizontal alignment (see above)
- 3 08H 1 = Text is wrapped at right border
- 6-4 70H XF_VERT_ALIGN . Vertical alignment (see above)
- 7 1 XF_ROTATION: Text rotation angle (see above)
- 8 1 Bit Mask Contents
- 3-0 0FH Indent level
- 4 10H 1 = Shrink content to fit into cell
- 5 merge
- 7-6 C0H Text direction (BIFF8X only)
- 00b = According to context
- 01b = Left-to-right
- 10b = Right-to-left
- 9 1 Bit Mask Contents
- 7-2 FCH XF_USED_ATTRIB . Used attributes (see above)
- 10 4 Cell border lines and background area:
- Bit Mask Contents
- 3-0 0000000FH Left line style
- 7-4 000000F0H Right line style
- 11-8 00000F00H Top line style
- 15-12 0000F000H Bottom line style
- 22-16 007F0000H Colour index for left line colour
- 29-23 3F800000H Colour index for right line colour
- 30 40000000H 1 = Diagonal line from top left to right bottom
- 31 80000000H 1 = Diagonal line from bottom left to right top
- 14 4 Bit Mask Contents
- 6-0 0000007FH Colour index for top line colour
- 13-7 00003F80H Colour index for bottom line colour
- 20-14 001FC000H Colour index for diagonal line colour
- 24-21 01E00000H Diagonal line style
- 31-26 FC000000H Fill pattern
- 18 2 Bit Mask Contents
- 6-0 007FH Colour index for pattern colour
- 13-7 3F80H Colour index for pattern background
-
- """
- _REC_ID = 0x00E0
-
- def __init__(self, xf, xftype='cell'):
- font_xf_idx, fmt_str_xf_idx, alignment, borders, pattern, protection = xf
- fnt = pack('<H', font_xf_idx)
- fmt = pack('<H', fmt_str_xf_idx)
- if xftype == 'cell':
- prt = pack('<H',
- ((protection.cell_locked & 0x01) << 0) |
- ((protection.formula_hidden & 0x01) << 1)
- )
- else:
- prt = pack('<H', 0xFFF5)
- aln = pack('B',
- ((alignment.horz & 0x07) << 0) |
- ((alignment.wrap & 0x01) << 3) |
- ((alignment.vert & 0x07) << 4)
- )
- rot = pack('B', alignment.rota)
- txt = pack('B',
- ((alignment.inde & 0x0F) << 0) |
- ((alignment.shri & 0x01) << 4) |
- ((alignment.merg & 0x01) << 5) |
- ((alignment.dire & 0x03) << 6)
- )
- if xftype == 'cell':
- used_attr = pack('B', 0xF8)
- else:
- used_attr = pack('B', 0xF4)
-
- if borders.left == borders.NO_LINE:
- borders.left_colour = 0x00
- if borders.right == borders.NO_LINE:
- borders.right_colour = 0x00
- if borders.top == borders.NO_LINE:
- borders.top_colour = 0x00
- if borders.bottom == borders.NO_LINE:
- borders.bottom_colour = 0x00
- if borders.diag == borders.NO_LINE:
- borders.diag_colour = 0x00
- brd1 = pack('<L',
- ((borders.left & 0x0F) << 0 ) |
- ((borders.right & 0x0F) << 4 ) |
- ((borders.top & 0x0F) << 8 ) |
- ((borders.bottom & 0x0F) << 12) |
- ((borders.left_colour & 0x7F) << 16) |
- ((borders.right_colour & 0x7F) << 23) |
- ((borders.need_diag1 & 0x01) << 30) |
- ((borders.need_diag2 & 0x01) << 31)
- )
- brd2 = pack('<L',
- ((borders.top_colour & 0x7F) << 0 ) |
- ((borders.bottom_colour & 0x7F) << 7 ) |
- ((borders.diag_colour & 0x7F) << 14) |
- ((borders.diag & 0x0F) << 21) |
- ((pattern.pattern & 0x3F) << 26)
- )
- pat = pack('<H',
- ((pattern.pattern_fore_colour & 0x7F) << 0 ) |
- ((pattern.pattern_back_colour & 0x7F) << 7 )
- )
- self._rec_data = fnt + fmt + prt + \
- aln + rot + txt + used_attr + \
- brd1 + brd2 + \
- pat
-
-class StyleRecord(BiffRecord):
- """
- STYLE record for user-defined cell styles, BIFF3-BIFF8:
- Offset Size Contents
- 0 2 Bit Mask Contents
- 11-0 0FFFH Index to style XF record
- 15 8000H Always 0 for user-defined styles
- 2 var. BIFF2-BIFF7: Non-empty byte string, 8-bit string length
- BIFF8: Non-empty Unicode string, 16-bit string length
- STYLE record for built-in cell styles, BIFF3-BIFF8:
- Offset Size Contents
- 0 2 Bit Mask Contents
- 11-0 0FFFH Index to style XF record
- 15 8000H Always 1 for built-in styles
- 2 1 Identifier of the built-in cell style:
- 00H = Normal
- 01H = RowLevel_lv (see next field)
- 02H = ColLevel_lv (see next field)
- 03H = Comma
- 04H = Currency
- 05H = Percent
- 06H = Comma [0] (BIFF4-BIFF8)
- 07H = Currency [0] (BIFF4-BIFF8)
- 08H = Hyperlink (BIFF8)
- 09H = Followed Hyperlink (BIFF8)
- 3 1 Level for RowLevel or ColLevel style
- (zero-based, lv), FFH otherwise
- The RowLevel and ColLevel styles specify the formatting of subtotal
- cells in a specific outline level. The level is specified by the last
- field in the STYLE record. Valid values are 0-6 for the outline levels
- 1-7.
- """
- _REC_ID = 0x0293
-
- def __init__(self):
- self._rec_data = pack('<HBB', 0x8000, 0x00, 0xFF)
- # TODO: implement user-defined styles???
-
-
-class PaletteRecord(BiffRecord):
- """
- This record contains the definition of all user-defined colours
- available for cell and object formatting.
-
- Record PALETTE, BIFF3-BIFF8:
-
- Offset Size Contents
- 0 2 Number of following colours (nm). Contains 16 in BIFF3-BIFF4 and 56 in BIFF5-BIFF8.
- 2 4*nm List of nm RGB colours
-
- The following table shows how colour indexes are used in other records:
-
- Colour index Resulting colour or internal list index
- 00H Built-in Black (R = 00H, G = 00H, B = 00H)
- 01H Built-in White (R = FFH, G = FFH, B = FFH)
- 02H Built-in Red (R = FFH, G = 00H, B = 00H)
- 03H Built-in Green (R = 00H, G = FFH, B = 00H)
- 04H Built-in Blue (R = 00H, G = 00H, B = FFH)
- 05H Built-in Yellow (R = FFH, G = FFH, B = 00H)
- 06H Built-in Magenta (R = FFH, G = 00H, B = FFH)
- 07H Built-in Cyan (R = 00H, G = FFH, B = FFH)
- 08H First user-defined colour from the PALETTE record (entry 0 from record colour list)
- .........................
-
- 17H (BIFF3-BIFF4) Last user-defined colour from the PALETTE record (entry 15 or 55 from record colour list)
- 3FH (BIFF5-BIFF8)
-
- 18H (BIFF3-BIFF4) System window text colour for border lines (used in records XF, CF, and
- 40H (BIFF5-BIFF8) WINDOW2 (BIFF8 only))
-
- 19H (BIFF3-BIFF4) System window background colour for pattern background (used in records XF, and CF)
- 41H (BIFF5-BIFF8)
-
- 43H System face colour (dialogue background colour)
- 4DH System window text colour for chart border lines
- 4EH System window background colour for chart areas
- 4FH Automatic colour for chart border lines (seems to be always Black)
- 50H System ToolTip background colour (used in note objects)
- 51H System ToolTip text colour (used in note objects)
- 7FFFH System window text colour for fonts (used in records FONT, EFONT, and CF)
-
- """
- _REC_ID = 0x0092
-
-
-class BoundSheetRecord(BiffRecord):
- """
- This record is located in the workbook globals area and represents
- a sheet inside of the workbook. For each sheet a BOUNDSHEET record
- is written. It stores the sheet name and a stream offset to the BOF
- record within the workbook stream. The record is also known
- as BUNDLESHEET.
-
- Record BOUNDSHEET, BIFF5-BIFF8:
- Offset Size Contents
- 0 4 Absolute stream position of the BOF record of the sheet represented by this record. This
- field is never encrypted in protected files.
- 4 1 Visibility:
- 00H = Visible
- 01H = Hidden
- 02H = Strong hidden
- 5 1 Sheet type:
- 00H = Worksheet
- 02H = Chart
- 06H = Visual Basic module
- 6 var. Sheet name:
- BIFF5/BIFF7: Byte string, 8-bit string length
- BIFF8: Unicode string, 8-bit string length
- """
- _REC_ID = 0x0085
-
- def __init__(self, stream_pos, visibility, sheetname, encoding='ascii'):
- usheetname = upack1(sheetname, encoding)
- uusheetname_len = len(usheetname)
-
- self._rec_data = pack('<LBB%ds' % uusheetname_len, stream_pos, visibility, 0x00, usheetname)
-
-
-class ContinueRecord(BiffRecord):
- """
- Whenever the content of a record exceeds the given limits (see table),
- the record must be split. Several CONTINUE records containing the
- additional data are added after the parent record.
-
- BIFF version Maximum data size of a record
- BIFF2-BIFF7 2080 bytes (2084 bytes including record header)
- BIFF8 8224 bytes (8228 bytes including record header) (0x2020)
-
- Record CONTINUE, BIFF2-BIFF8:
- Offset Size Contents
- 0 var. Data continuation of the previous record
-
- Unicode strings are split in a special way. At the beginning of each
- CONTINUE record the option flags byte is repeated. Only the character
- size flag will be set in this flags byte, the Rich-Text flag and the
- Far-East flag are set to zero. In each CONTINUE record it is possible
- that the character size changes from 8-bit characters to 16-bit
- characters and vice versa.
-
- Never a Unicode string is split until and including the first
- character. That means, all header fields (string length, option flags,
- optional Rich-Text size, and optional Far-East data size) and the first
- character of the string have to occur together in the leading record,
- or have to be moved completely into the CONTINUE record. Formatting
- runs cannot be split between their components (character index and FONT
- record index). If a string is split between two formatting runs, the
- option flags field will not be repeated in the CONTINUE record.
- """
- _REC_ID = 0x003C
-
-
-class SSTRecord(BiffRecord):
- """
- This record contains a list of all strings used anywhere in the
- workbook. Each string occurs only once. The workbook uses indexes into
- the list to reference the strings.
-
- Record SST, BIFF8:
- Offset Size Contents
- 0 4 Total number of strings in the workbook (see below)
- 4 4 Number of following strings (nm)
- 8 var. List of nm Unicode strings, 16-bit string length
-
- The first field of the SST record counts the total occurrence
- of strings in the workbook. For instance, the string AAA is used
- 3 times and the string BBB is used 2 times. The first field contains
- 5 and the second field contains 2, followed by the two strings.
- """
- _REC_ID = 0x00FC
-
-
-class ExtSSTRecord(BiffRecord):
- """
- This record occurs in conjunction with the SST record. It is used
- by Excel to create a hash table with stream offsets to the SST record
- to optimise string search operations. Excel may not shorten this record
- if strings are deleted from the shared string table, so the last part
- might contain invalid data. The stream indexes in this record divide
- the SST into portions containing a constant number of strings.
-
- Record EXTSST, BIFF8:
-
- Offset Size Contents
- 0 2 Number of strings in a portion, this number is >=8
- 2 var. List of OFFSET structures for all portions. Each OFFSET contains the following data:
- Offset Size Contents
- 0 4 Absolute stream position of first string of the portion
- 4 2 Position of first string of the portion inside of current record,
- including record header. This counter restarts at zero, if the SST
- record is continued with a CONTINUE record.
- 6 2 Not used
- """
- _REC_ID = 0x00FF
-
- def __init__(self, sst_stream_pos, str_placement, portions_len):
- extsst = {}
- abs_stream_pos = sst_stream_pos
- str_counter = 0
- portion_counter = 0
- while str_counter < len(str_placement):
- str_chunk_num, pos_in_chunk = str_placement[str_counter]
- if str_chunk_num <> portion_counter:
- portion_counter = str_chunk_num
- abs_stream_pos += portions_len[portion_counter-1]
- #print hex(abs_stream_pos)
- str_stream_pos = abs_stream_pos + pos_in_chunk + 4 # header
- extsst[str_counter] = (pos_in_chunk, str_stream_pos)
- str_counter += 1
-
- exsst_str_count_delta = max(8, len(str_placement)*8/0x2000) # maybe smth else?
- self._rec_data = pack('<H', exsst_str_count_delta)
- str_counter = 0
- while str_counter < len(str_placement):
- self._rec_data += pack('<IHH', extsst[str_counter][1], extsst[str_counter][0], 0)
- str_counter += exsst_str_count_delta
-
-class DimensionsRecord(BiffRecord):
- """
- Record DIMENSIONS, BIFF8:
-
- Offset Size Contents
- 0 4 Index to first used row
- 4 4 Index to last used row, increased by 1
- 8 2 Index to first used column
- 10 2 Index to last used column, increased by 1
- 12 2 Not used
- """
- _REC_ID = 0x0200
- def __init__(self, first_used_row, last_used_row, first_used_col, last_used_col):
- if first_used_row > last_used_row or first_used_col > last_used_col:
- # Special case: empty worksheet
- first_used_row = first_used_col = 0
- last_used_row = last_used_col = -1
- self._rec_data = pack('<2L3H',
- first_used_row, last_used_row + 1,
- first_used_col, last_used_col + 1,
- 0x00)
-
-
-class Window2Record(BiffRecord):
- """
- Record WINDOW2, BIFF8:
-
- Offset Size Contents
- 0 2 Option flags (see below)
- 2 2 Index to first visible row
- 4 2 Index to first visible column
- 6 2 Colour index of grid line colour. Note that in BIFF2-BIFF7 an RGB colour is
- written instead.
- 8 2 Not used
- 10 2 Cached magnification factor in page break preview (in percent); 0 = Default (60%)
- 12 2 Cached magnification factor in normal view (in percent); 0 = Default (100%)
- 14 4 Not used
-
- In BIFF8 this record stores used magnification factors for page break
- preview and normal view. These values are used to restore the
- magnification, when the view is changed. The real magnification of the
- currently active view is stored in the SCL record. The type of the
- active view is stored in the option flags field (see below).
-
- 0 0001H 0 = Show formula results 1 = Show formulas
- 1 0002H 0 = Do not show grid lines 1 = Show grid lines
- 2 0004H 0 = Do not show sheet headers 1 = Show sheet headers
- 3 0008H 0 = Panes are not frozen 1 = Panes are frozen (freeze)
- 4 0010H 0 = Show zero values as empty cells 1 = Show zero values
- 5 0020H 0 = Manual grid line colour 1 = Automatic grid line colour
- 6 0040H 0 = Columns from left to right 1 = Columns from right to left
- 7 0080H 0 = Do not show outline symbols 1 = Show outline symbols
- 8 0100H 0 = Keep splits if pane freeze is removed 1 = Remove splits if pane freeze is removed
- 9 0200H 0 = Sheet not selected 1 = Sheet selected (BIFF5-BIFF8)
- 10 0400H 0 = Sheet not visible 1 = Sheet visible (BIFF5-BIFF8)
- 11 0800H 0 = Show in normal view 1 = Show in page break preview (BIFF8)
-
- The freeze flag specifies, if a following PANE record describes unfrozen or frozen panes.
-
- *** This class appends the optional SCL record ***
-
- Record SCL, BIFF4-BIFF8:
-
- This record stores the magnification of the active view of the current worksheet.
- In BIFF8 this can be either the normal view or the page break preview.
- This is determined in the WINDOW2 record. The SCL record is part of the
- Sheet View Settings Block.
-
- Offset Size Contents
- 0 2 Numerator of the view magnification fraction (num)
- 2 2 Denumerator [denominator] of the view magnification fraction (den)
- The magnification is stored as reduced fraction. The magnification results from num/den.
-
- SJM note: Excel expresses (e.g.) 25% in reduced form i.e. 1/4. Reason unknown. This code
- writes 25/100, and Excel is happy with that.
-
- """
- _REC_ID = 0x023E
-
- def __init__(self, options, first_visible_row, first_visible_col,
- grid_colour, preview_magn, normal_magn, scl_magn):
- self._rec_data = pack('<7HL', options,
- first_visible_row, first_visible_col,
- grid_colour,
- 0x00,
- preview_magn, normal_magn,
- 0x00L)
- if scl_magn:
- self._scl_rec = pack('<4H', 0x00A0, 4, scl_magn, 100)
- else:
- self._scl_rec = ''
-
- def get(self):
- return self.get_rec_header() + self._rec_data + self._scl_rec
-
-
-class PanesRecord(BiffRecord):
- """
- This record stores the position of window panes. It is part of the Sheet
- View Settings Block. If the sheet does not contain any splits, this
- record will not occur.
- A sheet can be split in two different ways, with unfrozen panes or with
- frozen panes. A flag in the WINDOW2 record specifies, if the panes are
- frozen, which affects the contents of this record.
-
- Record PANE, BIFF2-BIFF8:
- Offset Size Contents
- 0 2 Position of the vertical split
- (px, 0 = No vertical split):
- Unfrozen pane: Width of the left pane(s)
- (in twips = 1/20 of a point)
- Frozen pane: Number of visible
- columns in left pane(s)
- 2 2 Position of the horizontal split
- (py, 0 = No horizontal split):
- Unfrozen pane: Height of the top pane(s)
- (in twips = 1/20 of a point)
- Frozen pane: Number of visible
- rows in top pane(s)
- 4 2 Index to first visible row
- in bottom pane(s)
- 6 2 Index to first visible column
- in right pane(s)
- 8 1 Identifier of pane with active
- cell cursor
- [9] 1 Not used (BIFF5-BIFF8 only, not written
- in BIFF2-BIFF4)
-
- If the panes are frozen, pane 0 is always active, regardless
- of the cursor position. The correct identifiers for all possible
- combinations of visible panes are shown in the following pictures.
-
- px = 0, py = 0 px = 0, py > 0
- -------------------------- ------------|-------------
- | | | |
- | | | 3 |
- | | | |
- - 3 - --------------------------
- | | | |
- | | | 2 |
- | | | |
- -------------------------- ------------|-------------
-
- px > 0, py = 0 px > 0, py > 0
- ------------|------------- ------------|-------------
- | | | | | |
- | | | | 3 | 2 |
- | | | | | |
- - 3 | 1 - --------------------------
- | | | | | |
- | | | | 1 | 0 |
- | | | | | |
- ------------|------------- ------------|-------------
- """
- _REC_ID = 0x0041
- def __init__(self, px, py, first_row_bottom, first_col_right, active_pane):
- self._rec_data = pack('<5H',
- px, py,
- first_row_bottom, first_col_right,
- active_pane)
-
-
-class RowRecord(BiffRecord):
- """
- This record contains the properties of a single row in a sheet. Rows
- and cells in a sheet are divided into blocks of 32 rows.
-
- Record ROW, BIFF3-BIFF8:
-
- Offset Size Contents
- 0 2 Index of this row
- 2 2 Index to column of the first cell which is described by a cell record
- 4 2 Index to column of the last cell which is described by a cell record,
- increased by 1
- 6 2 Bit Mask Contents
- 14-0 7FFFH Height of the row, in twips = 1/20 of a point
- 15 8000H 0 = Row has custom height; 1 = Row has default height
- 8 2 Not used
- 10 2 In BIFF3-BIFF4 this field contains a relative offset
- to calculate stream position of the first cell record
- for this row. In BIFF5-BIFF8 this field is not used
- anymore, but the DBCELL record instead.
- 12 4 Option flags and default row formatting:
- Bit Mask Contents
- 2-0 00000007H Outline level of the row
- 4 00000010H 1 = Outline group starts or ends here (depending
- on where the outline buttons are located,
- see WSBOOL record), and is collapsed
- 5 00000020H 1 = Row is hidden (manually, or by a filter or outline group)
- 6 00000040H 1 = Row height and default font height do not match
- 7 00000080H 1 = Row has explicit default format (fl)
- 8 00000100H Always 1
- 27-16 0FFF0000H If fl=1: Index to default XF record
- 28 10000000H 1 = Additional space above the row. This flag is set,
- if the upper border of at least one cell in this row
- or if the lower border of at least one cell in the row
- above is formatted with a thick line style.
- Thin and medium line styles are not taken into account.
- 29 20000000H 1 = Additional space below the row. This flag is set,
- if the lower border of at least one cell in this row
- or if the upper border of at least one cell in the row
- below is formatted with a medium or thick line style.
- Thin line styles are not taken into account.
- """
-
- _REC_ID = 0x0208
-
- def __init__(self, index, first_col, last_col, height_options, options):
- self._rec_data = pack('<6HL', index, first_col, last_col + 1,
- height_options,
- 0x00, 0x00,
- options)
-
-class LabelSSTRecord(BiffRecord):
- """
- This record represents a cell that contains a string. It replaces the
- LABEL record and RSTRING record used in BIFF2-BIFF7.
- """
- _REC_ID = 0x00FD
-
- def __init__(self, row, col, xf_idx, sst_idx):
- self._rec_data = pack('<3HL', row, col, xf_idx, sst_idx)
-
-
-class MergedCellsRecord(BiffRecord):
- """
- This record contains all merged cell ranges of the current sheet.
-
- Record MERGEDCELLS, BIFF8:
-
- Offset Size Contents
- 0 var. Cell range address list with all merged ranges
-
- ------------------------------------------------------------------
-
- A cell range address list consists of a field with the number of ranges
- and the list of the range addresses.
-
- Cell range address list, BIFF8:
-
- Offset Size Contents
- 0 2 Number of following cell range addresses (nm)
- 2 8*nm List of nm cell range addresses
-
- ---------------------------------------------------------------------
- Cell range address, BIFF8:
-
- Offset Size Contents
- 0 2 Index to first row
- 2 2 Index to last row
- 4 2 Index to first column
- 6 2 Index to last column
-
- """
- _REC_ID = 0x00E5
-
- def __init__(self, merged_list):
- i = len(merged_list) - 1
- while i >= 0:
- j = 0
- merged = ''
- while (i >= 0) and (j < 0x403):
- r1, r2, c1, c2 = merged_list[i]
- merged += pack('<4H', r1, r2, c1, c2)
- i -= 1
- j += 1
- self._rec_data += pack('<3H', self._REC_ID, len(merged) + 2, j) + \
- merged
-
- # for some reason Excel doesn't use CONTINUE
- def get(self):
- return self._rec_data
-
-class MulBlankRecord(BiffRecord):
- """
- This record represents a cell range of empty cells. All cells are
- located in the same row.
-
- Record MULBLANK, BIFF5-BIFF8:
-
- Offset Size Contents
- 0 2 Index to row
- 2 2 Index to first column (fc)
- 4 2*nc List of nc=lc-fc+1 16-bit indexes to XF records
- 4+2*nc 2 Index to last column (lc)
- """
- _REC_ID = 0x00BE
-
- def __init__(self, row, first_col, last_col, xf_index):
- blanks_count = last_col-first_col+1
- self._rec_data = pack('%dH' % blanks_count, *([xf_index]*blanks_count))
- self._rec_data = pack('<2H', row, first_col) + self._rec_data + pack('<H', last_col)
-
-
-class BlankRecord(BiffRecord):
- """
- This record represents an empty cell.
-
- Record BLANK, BIFF5-BIFF8:
-
- Offset Size Contents
- 0 2 Index to row
- 2 2 Index to first column (fc)
- 4 2 indexes to XF record
- """
- _REC_ID = 0x0201
-
- def __init__(self, row, col, xf_index):
- self._rec_data = pack('<3H', row, col, xf_index)
-
-
-class RKRecord(BiffRecord):
- """
- This record represents a cell that contains an RK value (encoded integer or
- floating-point value). If a floating-point value cannot be encoded to an RK value,
- a NUMBER record will be written.
- """
- _REC_ID = 0x027E
-
- def __init__(self, row, col, xf_index, rk_encoded):
- self._rec_data = pack('<3Hi', row, col, xf_index, rk_encoded)
-
-
-class NumberRecord(BiffRecord):
- """
- This record represents a cell that contains an IEEE-754 floating-point value.
- """
- _REC_ID = 0x0203
-
- def __init__(self, row, col, xf_index, number):
- self._rec_data = pack('<3Hd', row, col, xf_index, number)
-
-class BoolErrRecord(BiffRecord):
- """
- This record represents a cell that contains a boolean or error value.
- """
- _REC_ID = 0x0205
-
- def __init__(self, row, col, xf_index, number, is_error):
- self._rec_data = pack('<3HBB', row, col, xf_index, number, is_error)
-
-
-class FormulaRecord(BiffRecord):
- """
- Offset Size Contents
- 0 2 Index to row
- 2 2 Index to column
- 4 2 Index to XF record
- 6 8 Result of the formula
- 14 2 Option flags:
- Bit Mask Contents
- 0 0001H 1 = Recalculate always
- 1 0002H 1 = Calculate on open
- 3 0008H 1 = Part of a shared formula
- 16 4 Not used
- 20 var. Formula data (RPN token array)
-
- """
- _REC_ID = 0x0006
-
- def __init__(self, row, col, xf_index, rpn, calc_flags=0):
- self._rec_data = pack('<3HQHL', row, col, xf_index, 0xFFFF000000000003, calc_flags & 3, 0) + rpn
-
-
-class GutsRecord(BiffRecord):
- """
- This record contains information about the layout of outline symbols.
-
- Record GUTS, BIFF3-BIFF8:
-
- Offset Size Contents
- 0 2 Width of the area to display row outlines (left of the sheet), in pixel
- 2 2 Height of the area to display column outlines (above the sheet), in pixel
- 4 2 Number of visible row outline levels (used row levels + 1; or 0, if not used)
- 6 2 Number of visible column outline levels (used column levels + 1; or 0, if not used)
-
- """
-
- _REC_ID = 0x0080
-
- def __init__(self, row_gut_width, col_gut_height, row_visible_levels, col_visible_levels):
- self._rec_data = pack('<4H', row_gut_width, col_gut_height, row_visible_levels, col_visible_levels)
-
-class WSBoolRecord(BiffRecord):
- """
- This record stores a 16 bit value with Boolean options for the current
- sheet. From BIFF5 on the "Save external linked values" option is moved
- to the record BOOKBOOL.
-
- Option flags of record WSBOOL, BIFF3-BIFF8:
-
- Bit Mask Contents
- 0 0001H 0 = Do not show automatic page breaks
- 1 = Show automatic page breaks
- 4 0010H 0 = Standard sheet
- 1 = Dialogue sheet (BIFF5-BIFF8)
- 5 0020H 0 = No automatic styles in outlines
- 1 = Apply automatic styles to outlines
- 6 0040H 0 = Outline buttons above outline group
- 1 = Outline buttons below outline group
- 7 0080H 0 = Outline buttons left of outline group
- 1 = Outline buttons right of outline group
- 8 0100H 0 = Scale printout in percent
- 1 = Fit printout to number of pages
- 9 0200H 0 = Save external linked values (BIFF3?BIFF4 only)
- 1 = Do not save external linked values (BIFF3?BIFF4 only)
- 10 0400H 0 = Do not show row outline symbols
- 1 = Show row outline symbols
- 11 0800H 0 = Do not show column outline symbols
- 1 = Show column outline symbols
- 13-12 3000H These flags specify the arrangement of windows.
- They are stored in BIFF4 only.
- 00 = Arrange windows tiled
- 01 = Arrange windows horizontal
- 10 = Arrange windows vertical112 = Arrange windows cascaded
- The following flags are valid for BIFF4-BIFF8 only:
- 14 4000H 0 = Standard expression evaluation
- 1 = Alternative expression evaluation
- 15 8000H 0 = Standard formula entries
- 1 = Alternative formula entries
-
- """
- _REC_ID = 0x0081
-
- def __init__(self, options):
- self._rec_data = pack('<H', options)
-
-class ColInfoRecord(BiffRecord):
- """
- This record specifies the width for a given range of columns.
- If a column does not have a corresponding COLINFO record,
- the width specified in the record STANDARDWIDTH is used. If
- this record is also not present, the contents of the record
- DEFCOLWIDTH is used instead.
- This record also specifies a default XF record to use for
- cells in the columns that are not described by any cell record
- (which contain the XF index for that cell). Additionally,
- the option flags field contains hidden, outline, and collapsed
- options applied at the columns.
-
- Record COLINFO, BIFF3-BIFF8:
-
- Offset Size Contents
- 0 2 Index to first column in the range
- 2 2 Index to last column in the range
- 4 2 Width of the columns in 1/256 of the width of the zero character, using default font
- (first FONT record in the file)
- 6 2 Index to XF record for default column formatting
- 8 2 Option flags:
- Bits Mask Contents
- 0 0001H 1 = Columns are hidden
- 10-8 0700H Outline level of the columns (0 = no outline)
- 12 1000H 1 = Columns are collapsed
- 10 2 Not used
-
- """
- _REC_ID = 0x007D
-
- def __init__(self, first_col, last_col, width, xf_index, options):
- self._rec_data = pack('<6H', first_col, last_col, width, xf_index, options, 0)
-
-class CalcModeRecord(BiffRecord):
- """
- This record is part of the Calculation Settings Block.
- It specifies whether to calculate formulas manually,
- automatically or automatically except for multiple table operations.
-
- Record CALCMODE, BIFF2-BIFF8:
-
- Offset Size Contents
- 0 2 FFFFH = automatic except for multiple table operations
- 0000H = manually
- 0001H = automatically (default)
- """
- _REC_ID = 0x000D
-
- def __init__(self, calc_mode):
- self._rec_data = pack('<h', calc_mode)
-
-
-class CalcCountRecord(BiffRecord):
- """
- This record is part of the Calculation Settings Block. It specifies the maximum
- number of times the formulas should be iteratively calculated. This is a fail-safe
- against mutually recursive formulas locking up a spreadsheet application.
-
- Record CALCCOUNT, BIFF2-BIFF8:
-
- Offset Size Contents
- 0 2 Maximum number of iterations allowed in circular references
- """
-
- _REC_ID = 0x000C
-
- def __init__(self, calc_count):
- self._rec_data = pack('<H', calc_count)
-
-class RefModeRecord(BiffRecord):
- """
- This record is part of the Calculation Settings Block.
- It stores which method is used to show cell addresses in formulas.
- The “RC” mode uses numeric indexes for rows and columns,
- i.e. “R(1)C(-1)”, or “R1C1:R2C2”.
- The “A1” mode uses characters for columns and numbers for rows,
- i.e. “B1”, or “$A$1:$B$2”.
-
- Record REFMODE, BIFF2-BIFF8:
-
- Offset Size Contents
- 0 2 0 = RC mode; 1 = A1 mode
-
- """
- _REC_ID = 0x00F
-
- def __init__(self, ref_mode):
- self._rec_data = pack('<H', ref_mode)
-
-class IterationRecord(BiffRecord):
- """
- This record is part of the Calculation Settings Block.
- It stores if iterations are allowed while calculating recursive formulas.
-
- Record ITERATION, BIFF2-BIFF8:
-
- Offset Size Contents
- 0 2 0 = Iterations off; 1 = Iterations on
- """
- _REC_ID = 0x011
-
- def __init__(self, iterations_on):
- self._rec_data = pack('<H', iterations_on)
-
-class DeltaRecord(BiffRecord):
- """
- This record is part of the Calculation Settings Block.
- It stores the maximum change of the result to exit an iteration.
-
- Record DELTA, BIFF2-BIFF8:
-
- Offset Size Contents
- 0 8 Maximum change in iteration
- (IEEE 754 floating-point value,
- 64bit double precision)
- """
- _REC_ID = 0x010
-
- def __init__(self, delta):
- self._rec_data = pack('<d', delta)
-
-class SaveRecalcRecord(BiffRecord):
- """
- This record is part of the Calculation Settings Block.
- It contains the “Recalculate before save” option in
- Excel's calculation settings dialogue.
-
- Record SAVERECALC, BIFF3-BIFF8:
-
- Offset Size Contents
- 0 2 0 = Do not recalculate;
- 1 = Recalculate before saving the document
-
- """
- _REC_ID = 0x05F
-
- def __init__(self, recalc):
- self._rec_data = pack('<H', recalc)
-
-class PrintHeadersRecord(BiffRecord):
- """
- This record stores if the row and column headers
- (the areas with row numbers and column letters) will be printed.
-
- Record PRINTHEADERS, BIFF2-BIFF8:
-
- Offset Size Contents
- 0 2 0 = Do not print row/column headers;
- 1 = Print row/column headers
- """
- _REC_ID = 0x02A
-
- def __init__(self, print_headers):
- self._rec_data = pack('<H', print_headers)
-
-
-class PrintGridLinesRecord(BiffRecord):
- """
- This record stores if sheet grid lines will be printed.
-
- Record PRINTGRIDLINES, BIFF2-BIFF8:
-
- Offset Size Contents
- 0 2 0 = Do not print sheet grid lines;
- 1 = Print sheet grid lines
-
- """
- _REC_ID = 0x02B
-
- def __init__(self, print_grid):
- self._rec_data = pack('<H', print_grid)
-
-
-class GridSetRecord(BiffRecord):
- """
- This record specifies if the option to print sheet grid lines
- (record PRINTGRIDLINES) has ever been changed.
-
- Record GRIDSET, BIFF3-BIFF8:
-
- Offset Size Contents
- 0 2 0 = Print grid lines option never changed
- 1 = Print grid lines option changed
- """
- _REC_ID = 0x082
-
- def __init__(self, print_grid_changed):
- self._rec_data = pack('<H', print_grid_changed)
-
-
-class DefaultRowHeightRecord(BiffRecord):
- """
- This record specifies the default height and default flags
- for rows that do not have a corresponding ROW record.
-
- Record DEFAULTROWHEIGHT, BIFF3-BIFF8:
-
- Offset Size Contents
- 0 2 Option flags:
- Bit Mask Contents
- 0 0001H 1 = Row height and default font height do not match
- 1 0002H 1 = Row is hidden
- 2 0004H 1 = Additional space above the row
- 3 0008H 1 = Additional space below the row
- 2 2 Default height for unused rows, in twips = 1/20 of a point
-
- """
- _REC_ID = 0x0225
-
- def __init__(self, options, def_height):
- self._rec_data = pack('<2H', options, def_height)
-
-
-class DefColWidthRecord(BiffRecord):
- """
- This record specifies the default column width for columns that
- do not have a specific width set using the record COLINFO or COLWIDTH.
- This record has no effect, if a STANDARDWIDTH record is present in the file.
-
- Record DEFCOLWIDTH, BIFF2-BIFF8:
-
- Offset Size Contents
- 0 2 Column width in characters, using the width of the zero
- character from default font (first FONT record in the file)
- """
- _REC_ID = 0x0055
-
- def __init__(self, def_width):
- self._rec_data = pack('<H', options, def_width)
-
-class HorizontalPageBreaksRecord(BiffRecord):
- """
- This record is part of the Page Settings Block. It contains all
- horizontal manual page breaks.
-
- Record HORIZONTALPAGEBREAKS, BIFF8:
- Offset Size Contents
- 0 2 Number of following row index structures (nm)
- 2 6nm List of nm row index structures. Each row index
- structure contains:
- Offset Size Contents
- 0 2 Index to first row below the page break
- 2 2 Index to first column of this page break
- 4 2 Index to last column of this page break
-
- The row indexes in the lists must be ordered ascending.
- If in BIFF8 a row contains several page breaks, they must be ordered
- ascending by start column index.
- """
- _REC_ID = 0x001B
-
- def __init__(self, breaks_list):
- self._rec_data = pack('<H', len(breaks_list))
- for r, c1, c2 in breaks_list:
- self._rec_data += pack('<3H', r, c1, c2)
-
-class VerticalPageBreaksRecord(BiffRecord):
- """
- This record is part of the Page Settings Block. It contains all
- vertical manual page breaks.
-
- Record VERTICALPAGEBREAKS, BIFF8:
- Offset Size Contents
- 0 2 Number of following column index structures (nm)
- 2 6nm List of nm column index structures. Each column index
- structure contains:
- Offset Size Contents
- 0 2 Index to first column following the page
- break
- 2 2 Index to first row of this page break
- 4 2 Index to last row of this page break
-
- The column indexes in the lists must be ordered ascending.
- If in BIFF8 a column contains several page breaks, they must be ordered
- ascending by start row index.
- """
- _REC_ID = 0x001A
-
- def __init__(self, breaks_list):
- self._rec_data = pack('<H', len(breaks_list))
- for r, c1, c2 in breaks_list:
- self._rec_data += pack('<3H', r, c1, c2)
-
-class HeaderRecord(BiffRecord):
- """
- This record is part of the Page Settings Block. It specifies the
- page header string for the current worksheet. If this record is not
- present or completely empty (record size is 0), the sheet does not
- contain a page header.
-
- Record HEADER for non-empty page header, BIFF2-BIFF8:
- Offset Size Contents
- 0 var. Page header string
- BIFF2-BIFF7: Non-empty byte string, 8bit string
- length
- BIFF8: Non-empty Unicode string, 16bit string length
- The header string may contain special commands, i.e. placeholders for
- the page number, current date, or text formatting attributes. These
- fields are represented by single letters (exception: font name and
- size, see below) with a leading ampersand ("&"). If the ampersand
- is part of the regular header text, it will be duplicated ("&&"). The
- page header is divided into 3 sections: the left, the centred, and the
- right section. Each section is introduced by a special command. All
- text and all commands following are part of the selected section. Each
- section starts with the text formatting specified in the default font
- (first FONT record in the file). Active formatting attributes from
- a previous section do not go into the next section.
-
- The following table shows all available commands:
-
- Command Contents
- && The "&" character itself
- &L Start of the left section
- &C Start of the centred section
- &R Start of the right section
- &P Current page number
- &N Page count
- &D Current date
- &T Current time
- &A Sheet name (BIFF5-BIFF8)
- &F File name without path
- &Z File path without file name (BIFF8X)
- &G Picture (BIFF8X)
- &B Bold on/off (BIFF2-BIFF4)
- &I Italic on/off (BIFF2-BIFF4)
- &U Underlining on/off
- &E Double underlining on/off (BIFF5-BIFF8)
- &S Strikeout on/off
- &X Superscript on/off (BIFF5-BIFF8)
- &Y Subscript on/off (BIFF5-BIFF8)
- &"<fontname>" Set new font <fontname>
- &"<fontname>,<fontstyle>"
- Set new font with specified style <fontstyle>.
- The style <fontstyle> is in most cases one of
- "Regular", "Bold", "Italic", or "Bold Italic".
- But this setting is dependent on the used font,
- it may differ (localised style names, or "Standard",
- "Oblique", ...). (BIFF5-BIFF8)
- &<fontheight> Set font height in points (<fontheight> is a decimal value).
- If this command is followed by a plain number to be printed
- in the header, it will be separated from the font height
- with a space character.
-
- """
- _REC_ID = 0x0014
-
- def __init__(self, header_str):
- self._rec_data = upack2(header_str)
-
-class FooterRecord(BiffRecord):
- """
- Semantic is equal to HEADER record
- """
- _REC_ID = 0x0015
-
- def __init__(self, footer_str):
- self._rec_data = upack2(footer_str)
-
-
-class HCenterRecord(BiffRecord):
- """
- This record is part of the Page Settings Block. It specifies if the
- sheet is centred horizontally when printed.
-
- Record HCENTER, BIFF3-BIFF8:
-
- Offset Size Contents
- 0 2 0 = Print sheet left aligned
- 1 = Print sheet centred horizontally
-
- """
- _REC_ID = 0x0083
-
- def __init__(self, is_horz_center):
- self._rec_data = pack('<H', is_horz_center)
-
-
-class VCenterRecord(BiffRecord):
- """
- This record is part of the Page Settings Block. It specifies if the
- sheet is centred vertically when printed.
-
- Record VCENTER, BIFF3-BIFF8:
-
- Offset Size Contents
- 0 2 0 = Print sheet aligned at top page border
- 1 = Print sheet vertically centred
-
- """
- _REC_ID = 0x0084
-
- def __init__(self, is_vert_center):
- self._rec_data = pack('<H', is_vert_center)
-
-
-class LeftMarginRecord(BiffRecord):
- """
- This record is part of the Page Settings Block. It contains the left
- page margin of the current worksheet.
-
- Record LEFTMARGIN, BIFF2-BIFF8:
-
- Offset Size Contents
- 0 8 Left page margin in inches
- (IEEE 754 floating-point value, 64bit double precision)
-
- """
- _REC_ID = 0x0026
-
- def __init__(self, margin):
- self._rec_data = pack('<d', margin)
-
-
-class RightMarginRecord(BiffRecord):
- """
- This record is part of the Page Settings Block. It contains the right
- page margin of the current worksheet.
-
- Offset Size Contents
- 0 8 Right page margin in inches
- (IEEE 754 floating-point value, 64?bit double precision)
-
- """
- _REC_ID = 0x0027
-
- def __init__(self, margin):
- self._rec_data = pack('<d', margin)
-
-class TopMarginRecord(BiffRecord):
- """
- This record is part of the Page Settings Block. It contains the top
- page margin of the current worksheet.
-
- Offset Size Contents
- 0 8 Top page margin in inches
- (IEEE 754 floating-point value, 64?bit double precision)
-
- """
- _REC_ID = 0x0028
-
- def __init__(self, margin):
- self._rec_data = pack('<d', margin)
-
-
-class BottomMarginRecord(BiffRecord):
- """
- This record is part of the Page Settings Block. It contains the bottom
- page margin of the current worksheet.
-
- Offset Size Contents
- 0 8 Bottom page margin in inches
- (IEEE 754 floating-point value, 64?bit double precision)
-
- """
- _REC_ID = 0x0029
-
- def __init__(self, margin):
- self._rec_data = pack('<d', margin)
-
-class SetupPageRecord(BiffRecord):
- """
- This record is part of the Page Settings Block. It stores the page
- format settings of the current sheet. The pages may be scaled in
- percent or by using an absolute number of pages. This setting is
- located in the WSBOOL record. If pages are scaled in percent,
- the scaling factor in this record is used, otherwise the "Fit to
- pages" values. One of the "Fit to pages" values may be 0. In this case
- the sheet is scaled to fit only to the other value.
-
- Record SETUP, BIFF5-BIFF8:
-
- Offset Size Contents
- 0 2 Paper size (see below)
- 2 2 Scaling factor in percent
- 4 2 Start page number
- 6 2 Fit worksheet width to this number of pages
- (0 = use as many as needed)
- 8 2 Fit worksheet height to this number of pages
- (0 = use as many as needed)
- 10 2 Option flags:
- Bit Mask Contents
- 0 0001H 0 = Print pages in columns
- 1 = Print pages in rows
- 1 0002H 0 = Landscape
- 1 = Portrait
- 2 0004H 1 = Paper size, scaling factor,
- paper orientation (portrait/landscape),
- print resolution and number of copies
- are not initialised
- 3 0008H 0 = Print coloured
- 1 = Print black and white
- 4 0010H 0 = Default print quality
- 1 = Draft quality
- 5 0020H 0 = Do not print cell notes
- 1 = Print cell notes
- 6 0040H 0 = Paper orientation setting is valid
- 1 = Paper orientation setting not
- initialised
- 7 0080H 0 = Automatic page numbers
- 1 = Use start page number
- The following flags are valid for BIFF8 only:
- 9 0200H 0 = Print notes as displayed
- 1 = Print notes at end of sheet
- 11-10 0C00H 00 = Print errors as displayed
- 01 = Do not print errors
- 10 = Print errors as "--"
- 11 = Print errors as "#N/A!"
- 12 2 Print resolution in dpi
- 14 2 Vertical print resolution in dpi
- 16 8 Header margin (IEEE 754 floating-point value,
- 64bit double precision)
- 24 8 Footer margin (IEEE 754 floating-point value,
- 64bit double precision)
- 32 2 Number of copies to print
-
-
- PAPER TYPES:
-
- Index Paper type Paper size
- 0 Undefined
- 1 Letter 8 1/2" x 11"
- 2 Letter small 8 1/2" x 11"
- 3 Tabloid 11" x 17"
- 4 Ledger 17" x 11"
- 5 Legal 8 1/2" x 14"
- 6 Statement 5 1/2" x 8 1/2"
- 7 Executive 7 1/4" x 10 1/2"
- 8 A3 297mm x 420mm
- 9 A4 210mm x 297mm
- 10 A4 small 210mm x 297mm
- 11 A5 148mm x 210mm
- 12 B4 (JIS) 257mm x 364mm
- 13 B5 (JIS) 182mm x 257mm
- 14 Folio 8 1/2" x 13"
- 15 Quarto 215mm x 275mm
- 16 10x14 10" x 14"
- 17 11x17 11" x 17"
- 18 Note 8 1/2" x 11"
- 19 Envelope #9 3 7/8" x 8 7/8"
- 20 Envelope #10 4 1/8" x 9 1/2"
- 21 Envelope #11 4 1/2" x 10 3/8"
- 22 Envelope #12 4 3/4" x 11"
- 23 Envelope #14 5" x 11 1/2"
- 24 C 17" x 22"
- 25 D 22" x 34"
- 26 E 34" x 44"
- 27 Envelope DL 110mm x 220mm
- 28 Envelope C5 162mm x 229mm
- 29 Envelope C3 324mm x 458mm
- 30 Envelope C4 229mm x 324mm
- 31 Envelope C6 114mm x 162mm
- 32 Envelope C6/C5 114mm x 229mm
- 33 B4 (ISO) 250mm x 353mm
- 34 B5 (ISO) 176mm x 250mm
- 35 B6 (ISO) 125mm x 176mm
- 36 Envelope Italy 110mm x 230mm
- 37 Envelope Monarch 3 7/8" x 7 1/2"
- 38 63/4 Envelope 3 5/8" x 6 1/2"
- 39 US Standard Fanfold 14 7/8" x 11"
- 40 German Std. Fanfold 8 1/2" x 12"
- 41 German Legal Fanfold 8 1/2" x 13"
- 42 B4 (ISO) 250mm x 353mm
- 43 Japanese Postcard 100mm x 148mm
- 44 9x11 9" x 11"
- 45 10x11 10" x 11"
- 46 15x11 15" x 11"
- 47 Envelope Invite 220mm x 220mm
- 48 Undefined
- 49 Undefined
- 50 Letter Extra 9 1/2" x 12"
- 51 Legal Extra 9 1/2" x 15"
- 52 Tabloid Extra 11 11/16" x 18"
- 53 A4 Extra 235mm x 322mm
- 54 Letter Transverse 8 1/2" x 11"
- 55 A4 Transverse 210mm x 297mm
- 56 Letter Extra Transv. 9 1/2" x 12"
- 57 Super A/A4 227mm x 356mm
- 58 Super B/A3 305mm x 487mm
- 59 Letter Plus 8 1/2" x 12 11/16"
- 60 A4 Plus 210mm x 330mm
- 61 A5 Transverse 148mm x 210mm
- 62 B5 (JIS) Transverse 182mm x 257mm
- 63 A3 Extra 322mm x 445mm
- 64 A5 Extra 174mm x 235mm
- 65 B5 (ISO) Extra 201mm x 276mm
- 66 A2 420mm x 594mm
- 67 A3 Transverse 297mm x 420mm
- 68 A3 Extra Transverse 322mm x 445mm
- 69 Dbl. Japanese Postcard 200mm x 148mm
- 70 A6 105mm x 148mm
- 71
- 72
- 73
- 74
- 75 Letter Rotated 11" x 8 1/2"
- 76 A3 Rotated 420mm x 297mm
- 77 A4 Rotated 297mm x 210mm
- 78 A5 Rotated 210mm x 148mm
- 79 B4 (JIS) Rotated 364mm x 257mm
- 80 B5 (JIS) Rotated 257mm x 182mm
- 81 Japanese Postcard Rot. 148mm x 100mm
- 82 Dbl. Jap. Postcard Rot. 148mm x 200mm
- 83 A6 Rotated 148mm x 105mm
- 84
- 85
- 86
- 87
- 88 B6 (JIS) 128mm x 182mm
- 89 B6 (JIS) Rotated 182mm x 128mm
- 90 12x11 12" x 11"
-
- """
- _REC_ID = 0x00A1
- def __init__(self, paper, scaling, start_num, fit_width_to, fit_height_to,
- options,
- hres, vres,
- header_margin, footer_margin,
- num_copies):
- self._rec_data = pack('<8H2dH', paper, scaling, start_num,
- fit_width_to, fit_height_to, \
- options,
- hres, vres,
- header_margin, footer_margin,
- num_copies)
-
-class NameRecord(BiffRecord):
- """
- This record is part of a Link Table. It contains the name and the token
- array of an internal defined name. Token arrays of defined names
- contain tokens with aberrant token classes.
-
- Record NAME, BIFF5/BIFF7:
- Offset Size Contents
- 0 2 Option flags, see below
- 2 1 Keyboard shortcut (only for command macro names, see below)
- 3 1 Length of the name (character count, ln)
- 4 2 Size of the formula data (sz)
- 6 2 0 = Global name, otherwise index to EXTERNSHEET record (one-based)
- 8 2 0 = Global name, otherwise index to sheet (one-based)
- 10 1 Length of menu text (character count, lm)
- 11 1 Length of description text (character count, ld)
- 12 1 Length of help topic text (character count, lh)
- 13 1 Length of status bar text (character count, ls)
- 14 ln Character array of the name
- 14+ln sz Formula data (RPN token array without size field, 4)
- 14+ln+sz lm Character array of menu text
- var. ld Character array of description text
- var. lh Character array of help topic text
- var. ls Character array of status bar text
-
- Record NAME, BIFF8:
- Offset Size Contents
- 0 2 Option flags, see below
- 2 1 Keyboard shortcut (only for command macro names, see below)
- 3 1 Length of the name (character count, ln)
- 4 2 Size of the formula data (sz)
- 6 2 Not used
- 8 2 0 = Global name, otherwise index to sheet (one-based)
- 10 1 Length of menu text (character count, lm)
- 11 1 Length of description text (character count, ld)
- 12 1 Length of help topic text (character count, lh)
- 13 1 Length of status bar text (character count, ls)
- 14 var. Name (Unicode string without length field, 3.4)
- var. sz Formula data (RPN token array without size field, 4)
- [var.] var. (optional, only if lm > 0) Menu text (Unicode string without length field, 3.4)
- [var.] var. (optional, only if ld > 0) Description text (Unicode string without length field, 3.4)
- [var.] var. (optional, only if lh > 0) Help topic text (Unicode string without length field, 3.4)
- [var.] var. (optional, only if ls > 0) Status bar text (Unicode string without length field, 3.4)
- """
- _REC_ID = 0x0018
-
- def __init__(self, options, keyboard_shortcut, name, sheet_index, rpn, menu_text='', desc_text='', help_text='', status_text=''):
- if type(name) == int:
- uname = chr(name)
- else:
- uname = upack1(name)[1:]
- uname_len = len(uname)
-
- #~ self._rec_data = pack('<HBBHHHBBBB%ds%ds' % (uname_len, len(rpn)), options, keyboard_shortcut, uname_len, len(rpn), 0x0000, sheet_index, len(menu_text), len(desc_text), len(help_text), len(status_text), uname, rpn) + menu_text + desc_text + help_text + status_text
- self._rec_data = pack('<HBBHHHBBBBB%ds%ds' % (uname_len, len(rpn)), options, keyboard_shortcut, uname_len, len(rpn), 0x0000, sheet_index, 0x00, len(menu_text), len(desc_text), len(help_text), len(status_text), uname, rpn) + menu_text + desc_text + help_text + status_text
-
-# Excel (both 2003 and 2007) don't like refs
-# split over a record boundary, which is what the
-# standard BiffRecord.get method does.
-
-# 8224 max data bytes in a BIFF record
-# 6 bytes per ref
-# 1370 = floor((8224 - 2) / 6.0) max refs in a record
-
-_maxRefPerRecord = 1370
-
-class ExternSheetRecord(BiffRecord):
- """
- In BIFF8 the record stores a list with indexes to SUPBOOK
- records (list of REF structures, 6.100). See 5.10.3 for
- details about external references in BIFF8.
-
- Record EXTERNSHEET, BIFF8:
- Offset Size Contents
- 0 2 Number of following REF structures (nm)
- 2 6nm List of nm REF structures. Each REF contains the following data:
- Offset Size Contents
- 0 2 Index to SUPBOOK record
- 2 2 Index to first SUPBOOK sheet
- 4 2 Index to last SUPBOOK sheet
- """
- _REC_ID = 0x0017
-
- def __init__(self, refs):
-
- # do we always need this ref? or only if there are no refs?
- # (I believe that if there are no refs then we should not generate the link table - Ruben)
- #refs.insert(0, (0,0,0))
-
- self.refs = refs
-
- def get(self):
- res = []
- nrefs = len(self.refs)
- for idx in xrange(0, nrefs, _maxRefPerRecord):
- chunk = self.refs[idx:idx+_maxRefPerRecord]
- krefs = len(chunk)
- if idx: # CONTINUE record
- header = pack("<HH", 0x003C, 6 * krefs)
- else: # ExternSheetRecord
- header = pack("<HHH", self._REC_ID, 6 * krefs + 2, nrefs)
- res.append(header)
- res.extend([pack("<HHH", *r) for r in chunk])
- return ''.join(res)
-
-class SupBookRecord(BiffRecord):
- """
- This record mainly stores the URL of an external document
- and a list of sheet names inside this document. Furthermore
- it is used to store DDE and OLE object links, or to indicate
- an internal 3D reference or an add-in function. See 5.10.3
- for details about external references in BIFF8.
-
- """
- _REC_ID = 0x01AE
-
-class InternalReferenceSupBookRecord(SupBookRecord):
- """
- In each file occurs a SUPBOOK that is used for internal 3D
- references. It stores the number of sheets of the own document.
-
- Record SUPBOOK for 3D references, BIFF8:
- Offset Size Contents
- 0 2 Number of sheets in this document
- 2 2 01H 04H (relict of BIFF5/BIFF7, the byte string "<04H>", see 3.9.1)
-
- """
-
- def __init__(self, num_sheets):
- self._rec_data = pack('<HBB', num_sheets, 0x01, 0x04)
-
-class XcallSupBookRecord(SupBookRecord):
- """
- Add-in function names are stored in EXTERNNAME records following this record.
-
- Offset Size Contents
- 0 2 0001H
- 2 2 01H 3AH (relict of BIFF5, the byte string ':', see EXTERNSHEET record, 5.41)
-
- """
-
- def __init__(self):
- self._rec_data = pack('<HBB', 1, 0x01, 0x3A)
-
-
-class ExternnameRecord(BiffRecord):
- """
- Record EXTERNNAME for external names and Analysis add-in functions, BIFF5-BIFF8:
- Offset Size Contents
- 0 2 Option flags (see below)
- 2 2 0 for global names, or:
- BIFF5: One-based index to EXTERNSHEET record containing the sheet name,
- BIFF8: One-based index to sheet list in preceding EXTERNALBOOK record.
- 4 2 Not used
- 6 var. BIFF5: Name (byte string, 8-bit string length, ?2.5.2).
- BIFF8: Name (Unicode string, 8-bit string length, ?2.5.3).
- See DEFINEDNAME record (?5.33) for a list of built-in names, if the built-in flag is set
- in the option flags above.
- var. var. Formula data (RPN token array, ?3)
-
- Option flags for external names (BIFF5-BIFF8)
- Bit Mask Contents
- 0 0001H 0 = Standard name; 1 = Built-in name
- 1 0002H 0 = Manual link; 1 = Automatic link (DDE links and OLE links only)
- 2 0004H 1 = Picture link (DDE links and OLE links only)
- 3 0008H 1 = This is the “StdDocumentName” identifier (DDE links only)
- 4 0010H 1 = OLE link
- 14-5 7FE0H Clipboard format of last successful update (DDE links and OLE links only)
- 15 8000H 1 = Iconified picture link (BIFF8 OLE links only)
- """
- _REC_ID = 0x0023
-
- def __init__(self, options=0, index=0, name=None, fmla=None):
- self._rec_data = pack('<HHH', options, index, 0) + upack1(name) + fmla
-
diff --git a/tablib/packages/xlwt/Bitmap.py b/tablib/packages/xlwt/Bitmap.py deleted file mode 100644 index 2d04346..0000000 --- a/tablib/packages/xlwt/Bitmap.py +++ /dev/null @@ -1,262 +0,0 @@ -# -*- coding: windows-1251 -*-
-
-# Portions are Copyright (C) 2005 Roman V. Kiseliov
-# Portions are Copyright (c) 2004 Evgeny Filatov <fufff@users.sourceforge.net>
-# Portions are Copyright (c) 2002-2004 John McNamara (Perl Spreadsheet::WriteExcel)
-
-from BIFFRecords import BiffRecord
-from struct import *
-
-
-def _size_col(sheet, col):
- return sheet.col_width(col)
-
-
-def _size_row(sheet, row):
- return sheet.row_height(row)
-
-
-def _position_image(sheet, row_start, col_start, x1, y1, width, height):
- """Calculate the vertices that define the position of the image as required by
- the OBJ record.
-
- +------------+------------+
- | A | B |
- +-----+------------+------------+
- | |(x1,y1) | |
- | 1 |(A1)._______|______ |
- | | | | |
- | | | | |
- +-----+----| BITMAP |-----+
- | | | | |
- | 2 | |______________. |
- | | | (B2)|
- | | | (x2,y2)|
- +---- +------------+------------+
-
- Example of a bitmap that covers some of the area from cell A1 to cell B2.
-
- Based on the width and height of the bitmap we need to calculate 8 vars:
- col_start, row_start, col_end, row_end, x1, y1, x2, y2.
- The width and height of the cells are also variable and have to be taken into
- account.
- The values of col_start and row_start are passed in from the calling
- function. The values of col_end and row_end are calculated by subtracting
- the width and height of the bitmap from the width and height of the
- underlying cells.
- The vertices are expressed as a percentage of the underlying cell width as
- follows (rhs values are in pixels):
-
- x1 = X / W *1024
- y1 = Y / H *256
- x2 = (X-1) / W *1024
- y2 = (Y-1) / H *256
-
- Where: X is distance from the left side of the underlying cell
- Y is distance from the top of the underlying cell
- W is the width of the cell
- H is the height of the cell
-
- Note: the SDK incorrectly states that the height should be expressed as a
- percentage of 1024.
-
- col_start - Col containing upper left corner of object
- row_start - Row containing top left corner of object
- x1 - Distance to left side of object
- y1 - Distance to top of object
- width - Width of image frame
- height - Height of image frame
-
- """
- # Adjust start column for offsets that are greater than the col width
- while x1 >= _size_col(sheet, col_start):
- x1 -= _size_col(sheet, col_start)
- col_start += 1
- # Adjust start row for offsets that are greater than the row height
- while y1 >= _size_row(sheet, row_start):
- y1 -= _size_row(sheet, row_start)
- row_start += 1
- # Initialise end cell to the same as the start cell
- row_end = row_start # Row containing bottom right corner of object
- col_end = col_start # Col containing lower right corner of object
- width = width + x1 - 1
- height = height + y1 - 1
- # Subtract the underlying cell widths to find the end cell of the image
- while (width >= _size_col(sheet, col_end)):
- width -= _size_col(sheet, col_end)
- col_end += 1
- # Subtract the underlying cell heights to find the end cell of the image
- while (height >= _size_row(sheet, row_end)):
- height -= _size_row(sheet, row_end)
- row_end += 1
- # Bitmap isn't allowed to start or finish in a hidden cell, i.e. a cell
- # with zero height or width.
- if ((_size_col(sheet, col_start) == 0) or (_size_col(sheet, col_end) == 0)
- or (_size_row(sheet, row_start) == 0) or (_size_row(sheet, row_end) == 0)):
- return
- # Convert the pixel values to the percentage value expected by Excel
- x1 = int(float(x1) / _size_col(sheet, col_start) * 1024)
- y1 = int(float(y1) / _size_row(sheet, row_start) * 256)
- # Distance to right side of object
- x2 = int(float(width) / _size_col(sheet, col_end) * 1024)
- # Distance to bottom of object
- y2 = int(float(height) / _size_row(sheet, row_end) * 256)
- return (col_start, x1, row_start, y1, col_end, x2, row_end, y2)
-
-
-class ObjBmpRecord(BiffRecord):
- _REC_ID = 0x005D # Record identifier
-
- def __init__(self, row, col, sheet, im_data_bmp, x, y, scale_x, scale_y):
- # Scale the frame of the image.
- width = im_data_bmp.width * scale_x
- height = im_data_bmp.height * scale_y
-
- # Calculate the vertices of the image and write the OBJ record
- coordinates = _position_image(sheet, row, col, x, y, width, height)
- # print coordinates
- col_start, x1, row_start, y1, col_end, x2, row_end, y2 = coordinates
-
- """Store the OBJ record that precedes an IMDATA record. This could be generalise
- to support other Excel objects.
-
- """
- cObj = 0x0001 # Count of objects in file (set to 1)
- OT = 0x0008 # Object type. 8 = Picture
- id = 0x0001 # Object ID
- grbit = 0x0614 # Option flags
- colL = col_start # Col containing upper left corner of object
- dxL = x1 # Distance from left side of cell
- rwT = row_start # Row containing top left corner of object
- dyT = y1 # Distance from top of cell
- colR = col_end # Col containing lower right corner of object
- dxR = x2 # Distance from right of cell
- rwB = row_end # Row containing bottom right corner of object
- dyB = y2 # Distance from bottom of cell
- cbMacro = 0x0000 # Length of FMLA structure
- Reserved1 = 0x0000 # Reserved
- Reserved2 = 0x0000 # Reserved
- icvBack = 0x09 # Background colour
- icvFore = 0x09 # Foreground colour
- fls = 0x00 # Fill pattern
- fAuto = 0x00 # Automatic fill
- icv = 0x08 # Line colour
- lns = 0xff # Line style
- lnw = 0x01 # Line weight
- fAutoB = 0x00 # Automatic border
- frs = 0x0000 # Frame style
- cf = 0x0009 # Image format, 9 = bitmap
- Reserved3 = 0x0000 # Reserved
- cbPictFmla = 0x0000 # Length of FMLA structure
- Reserved4 = 0x0000 # Reserved
- grbit2 = 0x0001 # Option flags
- Reserved5 = 0x0000 # Reserved
-
- data = pack("<L", cObj)
- data += pack("<H", OT)
- data += pack("<H", id)
- data += pack("<H", grbit)
- data += pack("<H", colL)
- data += pack("<H", dxL)
- data += pack("<H", rwT)
- data += pack("<H", dyT)
- data += pack("<H", colR)
- data += pack("<H", dxR)
- data += pack("<H", rwB)
- data += pack("<H", dyB)
- data += pack("<H", cbMacro)
- data += pack("<L", Reserved1)
- data += pack("<H", Reserved2)
- data += pack("<B", icvBack)
- data += pack("<B", icvFore)
- data += pack("<B", fls)
- data += pack("<B", fAuto)
- data += pack("<B", icv)
- data += pack("<B", lns)
- data += pack("<B", lnw)
- data += pack("<B", fAutoB)
- data += pack("<H", frs)
- data += pack("<L", cf)
- data += pack("<H", Reserved3)
- data += pack("<H", cbPictFmla)
- data += pack("<H", Reserved4)
- data += pack("<H", grbit2)
- data += pack("<L", Reserved5)
-
- self._rec_data = data
-
-def _process_bitmap(bitmap):
- """Convert a 24 bit bitmap into the modified internal format used by Windows.
- This is described in BITMAPCOREHEADER and BITMAPCOREINFO structures in the
- MSDN library.
-
- """
- # Open file and binmode the data in case the platform needs it.
- fh = file(bitmap, "rb")
- try:
- # Slurp the file into a string.
- data = fh.read()
- finally:
- fh.close()
- # Check that the file is big enough to be a bitmap.
- if len(data) <= 0x36:
- raise Exception("bitmap doesn't contain enough data.")
- # The first 2 bytes are used to identify the bitmap.
- if (data[:2] != "BM"):
- raise Exception("bitmap doesn't appear to to be a valid bitmap image.")
- # Remove bitmap data: ID.
- data = data[2:]
- # Read and remove the bitmap size. This is more reliable than reading
- # the data size at offset 0x22.
- #
- size = unpack("<L", data[:4])[0]
- size -= 0x36 # Subtract size of bitmap header.
- size += 0x0C # Add size of BIFF header.
- data = data[4:]
- # Remove bitmap data: reserved, offset, header length.
- data = data[12:]
- # Read and remove the bitmap width and height. Verify the sizes.
- width, height = unpack("<LL", data[:8])
- data = data[8:]
- if (width > 0xFFFF):
- raise Exception("bitmap: largest image width supported is 65k.")
- if (height > 0xFFFF):
- raise Exception("bitmap: largest image height supported is 65k.")
- # Read and remove the bitmap planes and bpp data. Verify them.
- planes, bitcount = unpack("<HH", data[:4])
- data = data[4:]
- if (bitcount != 24):
- raise Exception("bitmap isn't a 24bit true color bitmap.")
- if (planes != 1):
- raise Exception("bitmap: only 1 plane supported in bitmap image.")
- # Read and remove the bitmap compression. Verify compression.
- compression = unpack("<L", data[:4])[0]
- data = data[4:]
- if (compression != 0):
- raise Exception("bitmap: compression not supported in bitmap image.")
- # Remove bitmap data: data size, hres, vres, colours, imp. colours.
- data = data[20:]
- # Add the BITMAPCOREHEADER data
- header = pack("<LHHHH", 0x000c, width, height, 0x01, 0x18)
- data = header + data
- return (width, height, size, data)
-
-
-class ImDataBmpRecord(BiffRecord):
- _REC_ID = 0x007F
-
- def __init__(self, filename):
- """Insert a 24bit bitmap image in a worksheet. The main record required is
- IMDATA but it must be proceeded by a OBJ record to define its position.
-
- """
- BiffRecord.__init__(self)
-
- self.width, self.height, self.size, data = _process_bitmap(filename)
- # Write the IMDATA record to store the bitmap data
- cf = 0x09
- env = 0x01
- lcb = self.size
- self._rec_data = pack("<HHL", cf, env, lcb) + data
-
-
diff --git a/tablib/packages/xlwt/Cell.py b/tablib/packages/xlwt/Cell.py deleted file mode 100644 index d0e72ad..0000000 --- a/tablib/packages/xlwt/Cell.py +++ /dev/null @@ -1,243 +0,0 @@ -# -*- coding: windows-1252 -*-
-
-from struct import unpack, pack
-import BIFFRecords
-
-class StrCell(object):
- __slots__ = ["rowx", "colx", "xf_idx", "sst_idx"]
-
- def __init__(self, rowx, colx, xf_idx, sst_idx):
- self.rowx = rowx
- self.colx = colx
- self.xf_idx = xf_idx
- self.sst_idx = sst_idx
-
- def get_biff_data(self):
- # return BIFFRecords.LabelSSTRecord(self.rowx, self.colx, self.xf_idx, self.sst_idx).get()
- return pack('<5HL', 0x00FD, 10, self.rowx, self.colx, self.xf_idx, self.sst_idx)
-
-class BlankCell(object):
- __slots__ = ["rowx", "colx", "xf_idx"]
-
- def __init__(self, rowx, colx, xf_idx):
- self.rowx = rowx
- self.colx = colx
- self.xf_idx = xf_idx
-
- def get_biff_data(self):
- # return BIFFRecords.BlankRecord(self.rowx, self.colx, self.xf_idx).get()
- return pack('<5H', 0x0201, 6, self.rowx, self.colx, self.xf_idx)
-
-class MulBlankCell(object):
- __slots__ = ["rowx", "colx1", "colx2", "xf_idx"]
-
- def __init__(self, rowx, colx1, colx2, xf_idx):
- self.rowx = rowx
- self.colx1 = colx1
- self.colx2 = colx2
- self.xf_idx = xf_idx
-
- def get_biff_data(self):
- return BIFFRecords.MulBlankRecord(self.rowx,
- self.colx1, self.colx2, self.xf_idx).get()
-
-class NumberCell(object):
- __slots__ = ["rowx", "colx", "xf_idx", "number"]
-
- def __init__(self, rowx, colx, xf_idx, number):
- self.rowx = rowx
- self.colx = colx
- self.xf_idx = xf_idx
- self.number = float(number)
-
- def get_encoded_data(self):
- rk_encoded = 0
- num = self.number
-
- # The four possible kinds of RK encoding are *not* mutually exclusive.
- # The 30-bit integer variety picks up the most.
- # In the code below, the four varieties are checked in descending order
- # of bangs per buck, or not at all.
- # SJM 2007-10-01
-
- if -0x20000000 <= num < 0x20000000: # fits in 30-bit *signed* int
- inum = int(num)
- if inum == num: # survives round-trip
- # print "30-bit integer RK", inum, hex(inum)
- rk_encoded = 2 | (inum << 2)
- return 1, rk_encoded
-
- temp = num * 100
-
- if -0x20000000 <= temp < 0x20000000:
- # That was step 1: the coded value will fit in
- # a 30-bit signed integer.
- itemp = int(round(temp, 0))
- # That was step 2: "itemp" is the best candidate coded value.
- # Now for step 3: simulate the decoding,
- # to check for round-trip correctness.
- if itemp / 100.0 == num:
- # print "30-bit integer RK*100", itemp, hex(itemp)
- rk_encoded = 3 | (itemp << 2)
- return 1, rk_encoded
-
- if 0: # Cost of extra pack+unpack not justified by tiny yield.
- packed = pack('<d', num)
- w01, w23 = unpack('<2i', packed)
- if not w01 and not(w23 & 3):
- # 34 lsb are 0
- # print "float RK", w23, hex(w23)
- return 1, w23
-
- packed100 = pack('<d', temp)
- w01, w23 = unpack('<2i', packed100)
- if not w01 and not(w23 & 3):
- # 34 lsb are 0
- # print "float RK*100", w23, hex(w23)
- return 1, w23 | 1
-
- #print "Number"
- #print
- return 0, pack('<5Hd', 0x0203, 14, self.rowx, self.colx, self.xf_idx, num)
-
- def get_biff_data(self):
- isRK, value = self.get_encoded_data()
- if isRK:
- return pack('<5Hi', 0x27E, 10, self.rowx, self.colx, self.xf_idx, value)
- return value # NUMBER record already packed
-
-class BooleanCell(object):
- __slots__ = ["rowx", "colx", "xf_idx", "number"]
-
- def __init__(self, rowx, colx, xf_idx, number):
- self.rowx = rowx
- self.colx = colx
- self.xf_idx = xf_idx
- self.number = number
-
- def get_biff_data(self):
- return BIFFRecords.BoolErrRecord(self.rowx,
- self.colx, self.xf_idx, self.number, 0).get()
-
-error_code_map = {
- 0x00: 0, # Intersection of two cell ranges is empty
- 0x07: 7, # Division by zero
- 0x0F: 15, # Wrong type of operand
- 0x17: 23, # Illegal or deleted cell reference
- 0x1D: 29, # Wrong function or range name
- 0x24: 36, # Value range overflow
- 0x2A: 42, # Argument or function not available
- '#NULL!' : 0, # Intersection of two cell ranges is empty
- '#DIV/0!': 7, # Division by zero
- '#VALUE!': 36, # Wrong type of operand
- '#REF!' : 23, # Illegal or deleted cell reference
- '#NAME?' : 29, # Wrong function or range name
- '#NUM!' : 36, # Value range overflow
- '#N/A!' : 42, # Argument or function not available
-}
-
-class ErrorCell(object):
- __slots__ = ["rowx", "colx", "xf_idx", "number"]
-
- def __init__(self, rowx, colx, xf_idx, error_string_or_code):
- self.rowx = rowx
- self.colx = colx
- self.xf_idx = xf_idx
- try:
- self.number = error_code_map[error_string_or_code]
- except KeyError:
- raise Exception('Illegal error value (%r)' % error_string_or_code)
-
- def get_biff_data(self):
- return BIFFRecords.BoolErrRecord(self.rowx,
- self.colx, self.xf_idx, self.number, 1).get()
-
-class FormulaCell(object):
- __slots__ = ["rowx", "colx", "xf_idx", "frmla", "calc_flags"]
-
- def __init__(self, rowx, colx, xf_idx, frmla, calc_flags=0):
- self.rowx = rowx
- self.colx = colx
- self.xf_idx = xf_idx
- self.frmla = frmla
- self.calc_flags = calc_flags
-
- def get_biff_data(self):
- return BIFFRecords.FormulaRecord(self.rowx,
- self.colx, self.xf_idx, self.frmla.rpn(), self.calc_flags).get()
-
-# module-level function for *internal* use by the Row module
-
-def _get_cells_biff_data_mul(rowx, cell_items):
- # Return the BIFF data for all cell records in the row.
- # Adjacent BLANK|RK records are combined into MUL(BLANK|RK) records.
- pieces = []
- nitems = len(cell_items)
- i = 0
- while i < nitems:
- icolx, icell = cell_items[i]
- if isinstance(icell, NumberCell):
- isRK, value = icell.get_encoded_data()
- if not isRK:
- pieces.append(value) # pre-packed NUMBER record
- i += 1
- continue
- muldata = [(value, icell.xf_idx)]
- target = NumberCell
- elif isinstance(icell, BlankCell):
- muldata = [icell.xf_idx]
- target = BlankCell
- else:
- pieces.append(icell.get_biff_data())
- i += 1
- continue
- lastcolx = icolx
- j = i
- packed_record = ''
- for j in xrange(i+1, nitems):
- jcolx, jcell = cell_items[j]
- if jcolx != lastcolx + 1:
- nexti = j
- break
- if not isinstance(jcell, target):
- nexti = j
- break
- if target == NumberCell:
- isRK, value = jcell.get_encoded_data()
- if not isRK:
- packed_record = value
- nexti = j + 1
- break
- muldata.append((value, jcell.xf_idx))
- else:
- muldata.append(jcell.xf_idx)
- lastcolx = jcolx
- else:
- nexti = j + 1
- if target == NumberCell:
- if lastcolx == icolx:
- # RK record
- value, xf_idx = muldata[0]
- pieces.append(pack('<5Hi', 0x027E, 10, rowx, icolx, xf_idx, value))
- else:
- # MULRK record
- nc = lastcolx - icolx + 1
- pieces.append(pack('<4H', 0x00BD, 6 * nc + 6, rowx, icolx))
- pieces.append(''.join([pack('<Hi', xf_idx, value) for value, xf_idx in muldata]))
- pieces.append(pack('<H', lastcolx))
- else:
- if lastcolx == icolx:
- # BLANK record
- xf_idx = muldata[0]
- pieces.append(pack('<5H', 0x0201, 6, rowx, icolx, xf_idx))
- else:
- # MULBLANK record
- nc = lastcolx - icolx + 1
- pieces.append(pack('<4H', 0x00BE, 2 * nc + 6, rowx, icolx))
- pieces.append(''.join([pack('<H', xf_idx) for xf_idx in muldata]))
- pieces.append(pack('<H', lastcolx))
- if packed_record:
- pieces.append(packed_record)
- i = nexti
- return ''.join(pieces)
-
diff --git a/tablib/packages/xlwt/Column.py b/tablib/packages/xlwt/Column.py deleted file mode 100644 index 9b94525..0000000 --- a/tablib/packages/xlwt/Column.py +++ /dev/null @@ -1,34 +0,0 @@ -# -*- coding: windows-1252 -*-
-
-from BIFFRecords import ColInfoRecord
-
-class Column(object):
- def __init__(self, colx, parent_sheet):
- if not(isinstance(colx, int) and 0 <= colx <= 255):
- raise ValueError("column index (%r) not an int in range(256)" % colx)
- self._index = colx
- self._parent = parent_sheet
- self._parent_wb = parent_sheet.get_parent()
- self._xf_index = 0x0F
-
- self.width = 0x0B92
- self.hidden = 0
- self.level = 0
- self.collapse = 0
-
- def set_style(self, style):
- self._xf_index = self._parent_wb.add_style(style)
-
- def width_in_pixels(self):
- # *** Approximation ****
- return int(round(self.width * 0.0272 + 0.446, 0))
-
- def get_biff_record(self):
- options = (self.hidden & 0x01) << 0
- options |= (self.level & 0x07) << 8
- options |= (self.collapse & 0x01) << 12
-
- return ColInfoRecord(self._index, self._index, self.width, self._xf_index, options).get()
-
-
-
diff --git a/tablib/packages/xlwt/CompoundDoc.py b/tablib/packages/xlwt/CompoundDoc.py deleted file mode 100644 index 18b458b..0000000 --- a/tablib/packages/xlwt/CompoundDoc.py +++ /dev/null @@ -1,516 +0,0 @@ -# -*- coding: windows-1252 -*-
-
-import sys
-import struct
-
-class Reader:
- def __init__(self, filename, dump = False):
- self.dump = dump
- self.STREAMS = {}
-
- doc = file(filename, 'rb').read()
- self.header, self.data = doc[0:512], doc[512:]
- del doc
-
- self.__build_header()
- self.__build_MSAT()
- self.__build_SAT()
- self.__build_directory()
- self.__build_short_sectors_data()
-
- if len(self.short_sectors_data) > 0:
- self.__build_SSAT()
- else:
- if self.dump and (self.total_ssat_sectors != 0 or self.ssat_start_sid != -2):
- print 'NOTE: header says that must be', self.total_ssat_sectors, 'short sectors'
- print 'NOTE: starting at', self.ssat_start_sid, 'sector'
- print 'NOTE: but file does not contains data in short sectors'
- self.ssat_start_sid = -2
- self.total_ssat_sectors = 0
- self.SSAT = [-2]
-
- for dentry in self.dir_entry_list[1:]:
- (did,
- sz, name,
- t, c,
- did_left, did_right, did_root,
- dentry_start_sid,
- stream_size
- ) = dentry
- stream_data = ''
- if stream_size > 0:
- if stream_size >= self.min_stream_size:
- args = (self.data, self.SAT, dentry_start_sid, self.sect_size)
- else:
- args = (self.short_sectors_data, self.SSAT, dentry_start_sid, self.short_sect_size)
- stream_data = self.get_stream_data(*args)
-
- if name != '':
- # BAD IDEA: names may be equal. NEED use full paths...
- self.STREAMS[name] = stream_data
-
-
- def __build_header(self):
- self.doc_magic = self.header[0:8]
-
- if self.doc_magic != '\xD0\xCF\x11\xE0\xA1\xB1\x1A\xE1':
- raise Exception, 'Not an OLE file.'
-
- self.file_uid = self.header[8:24]
- self.rev_num = self.header[24:26]
- self.ver_num = self.header[26:28]
- self.byte_order = self.header[28:30]
- self.log2_sect_size, = struct.unpack('<H', self.header[30:32])
- self.log2_short_sect_size, = struct.unpack('<H', self.header[32:34])
- self.total_sat_sectors, = struct.unpack('<L', self.header[44:48])
- self.dir_start_sid, = struct.unpack('<l', self.header[48:52])
- self.min_stream_size, = struct.unpack('<L', self.header[56:60])
- self.ssat_start_sid, = struct.unpack('<l', self.header[60:64])
- self.total_ssat_sectors, = struct.unpack('<L', self.header[64:68])
- self.msat_start_sid, = struct.unpack('<l', self.header[68:72])
- self.total_msat_sectors, = struct.unpack('<L', self.header[72:76])
-
- self.sect_size = 1 << self.log2_sect_size
- self.short_sect_size = 1 << self.log2_short_sect_size
-
- if self.dump:
- print 'file magic: '
- print_bin_data(self.doc_magic)
-
- print 'file uid: '
- print_bin_data(self.file_uid)
-
- print 'revision number: '
- print_bin_data(self.rev_num)
-
- print 'version number: '
- print_bin_data(self.ver_num)
-
- print 'byte order: '
- print_bin_data(self.byte_order)
-
- print 'sector size :', hex(self.sect_size), self.sect_size
- #print 'total sectors in file :', hex(self.total_sectors), self.total_sectors
- print 'short sector size :', hex(self.short_sect_size), self.short_sect_size
- print 'Total number of sectors used for the SAT :', hex(self.total_sat_sectors), self.total_sat_sectors
- print 'SID of first sector of the directory stream:', hex(self.dir_start_sid), self.dir_start_sid
- print 'Minimum size of a standard stream :', hex(self.min_stream_size), self.min_stream_size
- print 'SID of first sector of the SSAT :', hex(self.ssat_start_sid), self.ssat_start_sid
- print 'Total number of sectors used for the SSAT :', hex(self.total_ssat_sectors), self.total_ssat_sectors
- print 'SID of first additional sector of the MSAT :', hex(self.msat_start_sid), self.msat_start_sid
- print 'Total number of sectors used for the MSAT :', hex(self.total_msat_sectors), self.total_msat_sectors
-
-
- def __build_MSAT(self):
- self.MSAT = list(struct.unpack('<109l', self.header[76:]))
-
- next = self.msat_start_sid
- while next > 0:
- msat_sector = struct.unpack('<128l', self.data[next*self.sect_size:(next+1)*self.sect_size])
- self.MSAT.extend(msat_sector[:127])
- next = msat_sector[-1]
-
- if self.dump:
- print 'MSAT (header part): \n', self.MSAT[:109]
- print 'additional MSAT sectors: \n', self.MSAT[109:]
-
-
- def __build_SAT(self):
- sat_stream = ''.join([self.data[i*self.sect_size:(i+1)*self.sect_size] for i in self.MSAT if i >= 0])
-
- sat_sids_count = len(sat_stream) >> 2
- self.SAT = struct.unpack('<%dl' % sat_sids_count, sat_stream) # SIDs tuple
-
- if self.dump:
- print 'SAT sid count:\n', sat_sids_count
- print 'SAT content:\n', self.SAT
-
-
- def __build_SSAT(self):
- ssat_stream = self.get_stream_data(self.data, self.SAT, self.ssat_start_sid, self.sect_size)
-
- ssids_count = len(ssat_stream) >> 2
- self.SSAT = struct.unpack('<%dl' % ssids_count, ssat_stream)
-
- if self.dump:
- print 'SSID count:', ssids_count
- print 'SSAT content:\n', self.SSAT
-
-
- def __build_directory(self):
- dir_stream = self.get_stream_data(self.data, self.SAT, self.dir_start_sid, self.sect_size)
-
- self.dir_entry_list = []
-
- i = 0
- while i < len(dir_stream):
- dentry = dir_stream[i:i+128] # 128 -- dir entry size
- i += 128
-
- did = len(self.dir_entry_list)
- sz, = struct.unpack('<H', dentry[64:66])
- if sz > 0 :
- name = dentry[0:sz-2].decode('utf_16_le', 'replace')
- else:
- name = u''
- t, = struct.unpack('B', dentry[66])
- c, = struct.unpack('B', dentry[67])
- did_left , = struct.unpack('<l', dentry[68:72])
- did_right , = struct.unpack('<l', dentry[72:76])
- did_root , = struct.unpack('<l', dentry[76:80])
- dentry_start_sid , = struct.unpack('<l', dentry[116:120])
- stream_size , = struct.unpack('<L', dentry[120:124])
-
- self.dir_entry_list.extend([(did, sz, name, t, c,
- did_left, did_right, did_root,
- dentry_start_sid, stream_size)])
-
- if self.dump:
- dentry_types = {
- 0x00: 'Empty',
- 0x01: 'User storage',
- 0x02: 'User stream',
- 0x03: 'LockBytes',
- 0x04: 'Property',
- 0x05: 'Root storage'
- }
- node_colours = {
- 0x00: 'Red',
- 0x01: 'Black'
- }
- print 'total directory entries:', len(self.dir_entry_list)
-
- for dentry in self.dir_entry_list:
- (did, sz, name, t, c,
- did_left, did_right, did_root,
- dentry_start_sid, stream_size) = dentry
- print 'DID', did
- print 'Size of the used area of the character buffer of the name:', sz
- print 'dir entry name:', repr(name)
- print 'type of entry:', t, dentry_types[t]
- print 'entry colour:', c, node_colours[c]
- print 'left child DID :', did_left
- print 'right child DID:', did_right
- print 'root DID :', did_root
- print 'start SID :', dentry_start_sid
- print 'stream size :', stream_size
- if stream_size == 0:
- print 'stream is empty'
- elif stream_size >= self.min_stream_size:
- print 'stream stored as normal stream'
- else:
- print 'stream stored as short-stream'
-
-
- def __build_short_sectors_data(self):
- (did, sz, name, t, c,
- did_left, did_right, did_root,
- dentry_start_sid, stream_size) = self.dir_entry_list[0]
- assert t == 0x05 # Short-Stream Container Stream (SSCS) resides in Root Storage
- if stream_size == 0:
- self.short_sectors_data = ''
- else:
- self.short_sectors_data = self.get_stream_data(self.data, self.SAT, dentry_start_sid, self.sect_size)
-
-
- def get_stream_data(self, data, SAT, start_sid, sect_size):
- sid = start_sid
- chunks = [(sid, sid)]
- stream_data = ''
-
- while SAT[sid] >= 0:
- next_in_chain = SAT[sid]
- last_chunk_start, last_chunk_finish = chunks[-1]
- if next_in_chain == last_chunk_finish + 1:
- chunks[-1] = last_chunk_start, next_in_chain
- else:
- chunks.extend([(next_in_chain, next_in_chain)])
- sid = next_in_chain
- for s, f in chunks:
- stream_data += data[s*sect_size:(f+1)*sect_size]
- #print chunks
- return stream_data
-
-
-def print_bin_data(data):
- i = 0
- while i < len(data):
- j = 0
- while (i < len(data)) and (j < 16):
- c = '0x%02X' % ord(data[i])
- sys.stdout.write(c)
- sys.stdout.write(' ')
- i += 1
- j += 1
- print
- if i == 0:
- print '<NO DATA>'
-
-
-
-# This implementation writes only 'Root Entry', 'Workbook' streams
-# and 2 empty streams for aligning directory stream on sector boundary
-#
-# LAYOUT:
-# 0 header
-# 76 MSAT (1st part: 109 SID)
-# 512 workbook stream
-# ... additional MSAT sectors if streams' size > about 7 Mb == (109*512 * 128)
-# ... SAT
-# ... directory stream
-#
-# NOTE: this layout is "ad hoc". It can be more general. RTFM
-
-class XlsDoc:
- SECTOR_SIZE = 0x0200
- MIN_LIMIT = 0x1000
-
- SID_FREE_SECTOR = -1
- SID_END_OF_CHAIN = -2
- SID_USED_BY_SAT = -3
- SID_USED_BY_MSAT = -4
-
- def __init__(self):
- #self.book_stream = '' # padded
- self.book_stream_sect = []
-
- self.dir_stream = ''
- self.dir_stream_sect = []
-
- self.packed_SAT = ''
- self.SAT_sect = []
-
- self.packed_MSAT_1st = ''
- self.packed_MSAT_2nd = ''
- self.MSAT_sect_2nd = []
-
- self.header = ''
-
- def __build_directory(self): # align on sector boundary
- self.dir_stream = ''
-
- dentry_name = '\x00'.join('Root Entry\x00') + '\x00'
- dentry_name_sz = len(dentry_name)
- dentry_name_pad = '\x00'*(64 - dentry_name_sz)
- dentry_type = 0x05 # root storage
- dentry_colour = 0x01 # black
- dentry_did_left = -1
- dentry_did_right = -1
- dentry_did_root = 1
- dentry_start_sid = -2
- dentry_stream_sz = 0
-
- self.dir_stream += struct.pack('<64s H 2B 3l 9L l L L',
- dentry_name + dentry_name_pad,
- dentry_name_sz,
- dentry_type,
- dentry_colour,
- dentry_did_left,
- dentry_did_right,
- dentry_did_root,
- 0, 0, 0, 0, 0, 0, 0, 0, 0,
- dentry_start_sid,
- dentry_stream_sz,
- 0
- )
-
- dentry_name = '\x00'.join('Workbook\x00') + '\x00'
- dentry_name_sz = len(dentry_name)
- dentry_name_pad = '\x00'*(64 - dentry_name_sz)
- dentry_type = 0x02 # user stream
- dentry_colour = 0x01 # black
- dentry_did_left = -1
- dentry_did_right = -1
- dentry_did_root = -1
- dentry_start_sid = 0
- dentry_stream_sz = self.book_stream_len
-
- self.dir_stream += struct.pack('<64s H 2B 3l 9L l L L',
- dentry_name + dentry_name_pad,
- dentry_name_sz,
- dentry_type,
- dentry_colour,
- dentry_did_left,
- dentry_did_right,
- dentry_did_root,
- 0, 0, 0, 0, 0, 0, 0, 0, 0,
- dentry_start_sid,
- dentry_stream_sz,
- 0
- )
-
- # padding
- dentry_name = ''
- dentry_name_sz = len(dentry_name)
- dentry_name_pad = '\x00'*(64 - dentry_name_sz)
- dentry_type = 0x00 # empty
- dentry_colour = 0x01 # black
- dentry_did_left = -1
- dentry_did_right = -1
- dentry_did_root = -1
- dentry_start_sid = -2
- dentry_stream_sz = 0
-
- self.dir_stream += struct.pack('<64s H 2B 3l 9L l L L',
- dentry_name + dentry_name_pad,
- dentry_name_sz,
- dentry_type,
- dentry_colour,
- dentry_did_left,
- dentry_did_right,
- dentry_did_root,
- 0, 0, 0, 0, 0, 0, 0, 0, 0,
- dentry_start_sid,
- dentry_stream_sz,
- 0
- ) * 2
-
- def __build_sat(self):
- # Build SAT
- book_sect_count = self.book_stream_len >> 9
- dir_sect_count = len(self.dir_stream) >> 9
-
- total_sect_count = book_sect_count + dir_sect_count
- SAT_sect_count = 0
- MSAT_sect_count = 0
- SAT_sect_count_limit = 109
- while total_sect_count > 128*SAT_sect_count or SAT_sect_count > SAT_sect_count_limit:
- SAT_sect_count += 1
- total_sect_count += 1
- if SAT_sect_count > SAT_sect_count_limit:
- MSAT_sect_count += 1
- total_sect_count += 1
- SAT_sect_count_limit += 127
-
-
- SAT = [self.SID_FREE_SECTOR]*128*SAT_sect_count
-
- sect = 0
- while sect < book_sect_count - 1:
- self.book_stream_sect.append(sect)
- SAT[sect] = sect + 1
- sect += 1
- self.book_stream_sect.append(sect)
- SAT[sect] = self.SID_END_OF_CHAIN
- sect += 1
-
- while sect < book_sect_count + MSAT_sect_count:
- self.MSAT_sect_2nd.append(sect)
- SAT[sect] = self.SID_USED_BY_MSAT
- sect += 1
-
- while sect < book_sect_count + MSAT_sect_count + SAT_sect_count:
- self.SAT_sect.append(sect)
- SAT[sect] = self.SID_USED_BY_SAT
- sect += 1
-
- while sect < book_sect_count + MSAT_sect_count + SAT_sect_count + dir_sect_count - 1:
- self.dir_stream_sect.append(sect)
- SAT[sect] = sect + 1
- sect += 1
- self.dir_stream_sect.append(sect)
- SAT[sect] = self.SID_END_OF_CHAIN
- sect += 1
-
- self.packed_SAT = struct.pack('<%dl' % (SAT_sect_count*128), *SAT)
-
- MSAT_1st = [self.SID_FREE_SECTOR]*109
- for i, SAT_sect_num in zip(range(0, 109), self.SAT_sect):
- MSAT_1st[i] = SAT_sect_num
- self.packed_MSAT_1st = struct.pack('<109l', *MSAT_1st)
-
- MSAT_2nd = [self.SID_FREE_SECTOR]*128*MSAT_sect_count
- if MSAT_sect_count > 0:
- MSAT_2nd[- 1] = self.SID_END_OF_CHAIN
-
- i = 109
- msat_sect = 0
- sid_num = 0
- while i < SAT_sect_count:
- if (sid_num + 1) % 128 == 0:
- #print 'link: ',
- msat_sect += 1
- if msat_sect < len(self.MSAT_sect_2nd):
- MSAT_2nd[sid_num] = self.MSAT_sect_2nd[msat_sect]
- else:
- #print 'sid: ',
- MSAT_2nd[sid_num] = self.SAT_sect[i]
- i += 1
- #print sid_num, MSAT_2nd[sid_num]
- sid_num += 1
-
- self.packed_MSAT_2nd = struct.pack('<%dl' % (MSAT_sect_count*128), *MSAT_2nd)
-
- #print vars()
- #print zip(range(0, sect), SAT)
- #print self.book_stream_sect
- #print self.MSAT_sect_2nd
- #print MSAT_2nd
- #print self.SAT_sect
- #print self.dir_stream_sect
-
-
- def __build_header(self):
- doc_magic = '\xD0\xCF\x11\xE0\xA1\xB1\x1A\xE1'
- file_uid = '\x00'*16
- rev_num = '\x3E\x00'
- ver_num = '\x03\x00'
- byte_order = '\xFE\xFF'
- log_sect_size = struct.pack('<H', 9)
- log_short_sect_size = struct.pack('<H', 6)
- not_used0 = '\x00'*10
- total_sat_sectors = struct.pack('<L', len(self.SAT_sect))
- dir_start_sid = struct.pack('<l', self.dir_stream_sect[0])
- not_used1 = '\x00'*4
- min_stream_size = struct.pack('<L', 0x1000)
- ssat_start_sid = struct.pack('<l', -2)
- total_ssat_sectors = struct.pack('<L', 0)
-
- if len(self.MSAT_sect_2nd) == 0:
- msat_start_sid = struct.pack('<l', -2)
- else:
- msat_start_sid = struct.pack('<l', self.MSAT_sect_2nd[0])
-
- total_msat_sectors = struct.pack('<L', len(self.MSAT_sect_2nd))
-
- self.header = ''.join([ doc_magic,
- file_uid,
- rev_num,
- ver_num,
- byte_order,
- log_sect_size,
- log_short_sect_size,
- not_used0,
- total_sat_sectors,
- dir_start_sid,
- not_used1,
- min_stream_size,
- ssat_start_sid,
- total_ssat_sectors,
- msat_start_sid,
- total_msat_sectors
- ])
-
-
- def save(self, file_name_or_filelike_obj, stream):
- # 1. Align stream on 0x1000 boundary (and therefore on sector boundary)
- padding = '\x00' * (0x1000 - (len(stream) % 0x1000))
- self.book_stream_len = len(stream) + len(padding)
-
- self.__build_directory()
- self.__build_sat()
- self.__build_header()
-
- f = file_name_or_filelike_obj
- we_own_it = not hasattr(f, 'write')
- if we_own_it:
- f = open(file_name_or_filelike_obj, 'wb')
- f.write(self.header)
- f.write(self.packed_MSAT_1st)
- f.write(stream)
- f.write(padding)
- f.write(self.packed_MSAT_2nd)
- f.write(self.packed_SAT)
- f.write(self.dir_stream)
- if we_own_it:
- f.close()
diff --git a/tablib/packages/xlwt/ExcelFormula.py b/tablib/packages/xlwt/ExcelFormula.py deleted file mode 100644 index abf295b..0000000 --- a/tablib/packages/xlwt/ExcelFormula.py +++ /dev/null @@ -1,43 +0,0 @@ -# -*- coding: windows-1252 -*-
-
-import ExcelFormulaParser, ExcelFormulaLexer
-import struct
-from antlr import ANTLRException
-
-
-class Formula(object):
- __slots__ = ["__init__", "__s", "__parser", "__sheet_refs", "__xcall_refs"]
-
-
- def __init__(self, s):
- try:
- self.__s = s
- lexer = ExcelFormulaLexer.Lexer(s)
- self.__parser = ExcelFormulaParser.Parser(lexer)
- self.__parser.formula()
- self.__sheet_refs = self.__parser.sheet_references
- self.__xcall_refs = self.__parser.xcall_references
- except ANTLRException, e:
- # print e
- raise ExcelFormulaParser.FormulaParseException, "can't parse formula " + s
-
- def get_references(self):
- return self.__sheet_refs, self.__xcall_refs
-
- def patch_references(self, patches):
- for offset, idx in patches:
- self.__parser.rpn = self.__parser.rpn[:offset] + struct.pack('<H', idx) + self.__parser.rpn[offset+2:]
-
- def text(self):
- return self.__s
-
- def rpn(self):
- '''
- Offset Size Contents
- 0 2 Size of the following formula data (sz)
- 2 sz Formula data (RPN token array)
- [2+sz] var. (optional) Additional data for specific tokens
-
- '''
- return struct.pack("<H", len(self.__parser.rpn)) + self.__parser.rpn
-
diff --git a/tablib/packages/xlwt/ExcelFormulaLexer.py b/tablib/packages/xlwt/ExcelFormulaLexer.py deleted file mode 100644 index dc78bae..0000000 --- a/tablib/packages/xlwt/ExcelFormulaLexer.py +++ /dev/null @@ -1,128 +0,0 @@ -# -*- coding: windows-1252 -*-
-
-import sys
-from antlr import EOF, CommonToken as Tok, TokenStream, TokenStreamException
-import struct
-import ExcelFormulaParser
-from re import compile as recompile, match, LOCALE, UNICODE, IGNORECASE, VERBOSE
-
-
-int_const_pattern = r"\d+\b"
-flt_const_pattern = r"""
- (?:
- (?: \d* \. \d+ ) # .1 .12 .123 etc 9.1 etc 98.1 etc
- |
- (?: \d+ \. ) # 1. 12. 123. etc
- )
- # followed by optional exponent part
- (?: [Ee] [+-]? \d+ ) ?
- """
-str_const_pattern = r'"(?:[^"]|"")*"'
-#range2d_pattern = recompile(r"\$?[A-I]?[A-Z]\$?\d+:\$?[A-I]?[A-Z]\$?\d+"
-ref2d_r1c1_pattern = r"[Rr]0*[1-9][0-9]*[Cc]0*[1-9][0-9]*"
-ref2d_pattern = r"\$?[A-I]?[A-Z]\$?0*[1-9][0-9]*"
-true_pattern = r"TRUE\b"
-false_pattern = r"FALSE\b"
-if_pattern = r"IF\b"
-choose_pattern = r"CHOOSE\b"
-name_pattern = r"\w[\.\w]*"
-quotename_pattern = r"'(?:[^']|'')*'" #### It's essential that this bracket be non-grouping.
-ne_pattern = r"<>"
-ge_pattern = r">="
-le_pattern = r"<="
-
-pattern_type_tuples = (
- (flt_const_pattern, ExcelFormulaParser.NUM_CONST),
- (int_const_pattern, ExcelFormulaParser.INT_CONST),
- (str_const_pattern, ExcelFormulaParser.STR_CONST),
-# (range2d_pattern , ExcelFormulaParser.RANGE2D),
- (ref2d_r1c1_pattern, ExcelFormulaParser.REF2D_R1C1),
- (ref2d_pattern , ExcelFormulaParser.REF2D),
- (true_pattern , ExcelFormulaParser.TRUE_CONST),
- (false_pattern , ExcelFormulaParser.FALSE_CONST),
- (if_pattern , ExcelFormulaParser.FUNC_IF),
- (choose_pattern , ExcelFormulaParser.FUNC_CHOOSE),
- (name_pattern , ExcelFormulaParser.NAME),
- (quotename_pattern, ExcelFormulaParser.QUOTENAME),
- (ne_pattern, ExcelFormulaParser.NE),
- (ge_pattern, ExcelFormulaParser.GE),
- (le_pattern, ExcelFormulaParser.LE),
-)
-
-_re = recompile(
- '(' + ')|('.join([i[0] for i in pattern_type_tuples]) + ')',
- VERBOSE+LOCALE+IGNORECASE)
-
-_toktype = [None] + [i[1] for i in pattern_type_tuples]
-# need dummy at start because re.MatchObject.lastindex counts from 1
-
-single_char_lookup = {
- '=': ExcelFormulaParser.EQ,
- '<': ExcelFormulaParser.LT,
- '>': ExcelFormulaParser.GT,
- '+': ExcelFormulaParser.ADD,
- '-': ExcelFormulaParser.SUB,
- '*': ExcelFormulaParser.MUL,
- '/': ExcelFormulaParser.DIV,
- ':': ExcelFormulaParser.COLON,
- ';': ExcelFormulaParser.SEMICOLON,
- ',': ExcelFormulaParser.COMMA,
- '(': ExcelFormulaParser.LP,
- ')': ExcelFormulaParser.RP,
- '&': ExcelFormulaParser.CONCAT,
- '%': ExcelFormulaParser.PERCENT,
- '^': ExcelFormulaParser.POWER,
- '!': ExcelFormulaParser.BANG,
- }
-
-class Lexer(TokenStream):
- def __init__(self, text):
- self._text = text[:]
- self._pos = 0
- self._line = 0
-
- def isEOF(self):
- return len(self._text) <= self._pos
-
- def curr_ch(self):
- return self._text[self._pos]
-
- def next_ch(self, n = 1):
- self._pos += n
-
- def is_whitespace(self):
- return self.curr_ch() in " \t\n\r\f\v"
-
- def match_pattern(self):
- m = _re.match(self._text, self._pos)
- if not m:
- return None
- self._pos = m.end(0)
- return Tok(type = _toktype[m.lastindex], text = m.group(0), col = m.start(0) + 1)
-
- def nextToken(self):
- # skip whitespace
- while not self.isEOF() and self.is_whitespace():
- self.next_ch()
- if self.isEOF():
- return Tok(type = EOF)
- # first, try to match token with 2 or more chars
- t = self.match_pattern()
- if t:
- return t
- # second, we want 1-char tokens
- te = self.curr_ch()
- try:
- ty = single_char_lookup[te]
- except KeyError:
- raise TokenStreamException(
- "Unexpected char %r in column %u." % (self.curr_ch(), self._pos))
- self.next_ch()
- return Tok(type=ty, text=te, col=self._pos)
-
-if __name__ == '__main__':
- try:
- for t in Lexer(""" 1.23 456 "abcd" R2C2 a1 iv65536 true false if choose a_name 'qname' <> >= <= """):
- print t
- except TokenStreamException, e:
- print "error:", e
diff --git a/tablib/packages/xlwt/ExcelFormulaParser.py b/tablib/packages/xlwt/ExcelFormulaParser.py deleted file mode 100644 index 28cee47..0000000 --- a/tablib/packages/xlwt/ExcelFormulaParser.py +++ /dev/null @@ -1,677 +0,0 @@ -### $ANTLR 2.7.7 (20060930): "xlwt/excel-formula.g" -> "ExcelFormulaParser.py"$
-### import antlr and other modules ..
-import sys
-import antlr
-
-version = sys.version.split()[0]
-if version < '2.2.1':
- False = 0
-if version < '2.3':
- True = not False
-### header action >>>
-import struct
-import Utils
-from UnicodeUtils import upack1
-from ExcelMagic import *
-
-_RVAdelta = {"R": 0, "V": 0x20, "A": 0x40}
-_RVAdeltaRef = {"R": 0, "V": 0x20, "A": 0x40, "D": 0x20}
-_RVAdeltaArea = {"R": 0, "V": 0x20, "A": 0x40, "D": 0}
-
-
-class FormulaParseException(Exception):
- """
- An exception indicating that a Formula could not be successfully parsed.
- """
-### header action <<<
-### preamble action>>>
-
-### preamble action <<<
-
-### import antlr.Token
-from antlr import Token
-### >>>The Known Token Types <<<
-SKIP = antlr.SKIP
-INVALID_TYPE = antlr.INVALID_TYPE
-EOF_TYPE = antlr.EOF_TYPE
-EOF = antlr.EOF
-NULL_TREE_LOOKAHEAD = antlr.NULL_TREE_LOOKAHEAD
-MIN_USER_TYPE = antlr.MIN_USER_TYPE
-TRUE_CONST = 4
-FALSE_CONST = 5
-STR_CONST = 6
-NUM_CONST = 7
-INT_CONST = 8
-FUNC_IF = 9
-FUNC_CHOOSE = 10
-NAME = 11
-QUOTENAME = 12
-EQ = 13
-NE = 14
-GT = 15
-LT = 16
-GE = 17
-LE = 18
-ADD = 19
-SUB = 20
-MUL = 21
-DIV = 22
-POWER = 23
-PERCENT = 24
-LP = 25
-RP = 26
-LB = 27
-RB = 28
-COLON = 29
-COMMA = 30
-SEMICOLON = 31
-REF2D = 32
-REF2D_R1C1 = 33
-BANG = 34
-CONCAT = 35
-
-class Parser(antlr.LLkParser):
- ### user action >>>
- ### user action <<<
-
- def __init__(self, *args, **kwargs):
- antlr.LLkParser.__init__(self, *args, **kwargs)
- self.tokenNames = _tokenNames
- ### __init__ header action >>>
- self.rpn = ""
- self.sheet_references = []
- self.xcall_references = []
- ### __init__ header action <<<
-
- def formula(self):
-
- pass
- self.expr("V")
-
- def expr(self,
- arg_type
- ):
-
- pass
- self.prec0_expr(arg_type)
- while True:
- if ((self.LA(1) >= EQ and self.LA(1) <= LE)):
- pass
- la1 = self.LA(1)
- if False:
- pass
- elif la1 and la1 in [EQ]:
- pass
- self.match(EQ)
- op = struct.pack('B', ptgEQ)
- elif la1 and la1 in [NE]:
- pass
- self.match(NE)
- op = struct.pack('B', ptgNE)
- elif la1 and la1 in [GT]:
- pass
- self.match(GT)
- op = struct.pack('B', ptgGT)
- elif la1 and la1 in [LT]:
- pass
- self.match(LT)
- op = struct.pack('B', ptgLT)
- elif la1 and la1 in [GE]:
- pass
- self.match(GE)
- op = struct.pack('B', ptgGE)
- elif la1 and la1 in [LE]:
- pass
- self.match(LE)
- op = struct.pack('B', ptgLE)
- else:
- raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
- self.prec0_expr(arg_type)
- self.rpn += op
- else:
- break
-
-
- def prec0_expr(self,
- arg_type
- ):
-
- pass
- self.prec1_expr(arg_type)
- while True:
- if (self.LA(1)==CONCAT):
- pass
- pass
- self.match(CONCAT)
- op = struct.pack('B', ptgConcat)
- self.prec1_expr(arg_type)
- self.rpn += op
- else:
- break
-
-
- def prec1_expr(self,
- arg_type
- ):
-
- pass
- self.prec2_expr(arg_type)
- while True:
- if (self.LA(1)==ADD or self.LA(1)==SUB):
- pass
- la1 = self.LA(1)
- if False:
- pass
- elif la1 and la1 in [ADD]:
- pass
- self.match(ADD)
- op = struct.pack('B', ptgAdd)
- elif la1 and la1 in [SUB]:
- pass
- self.match(SUB)
- op = struct.pack('B', ptgSub)
- else:
- raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
- self.prec2_expr(arg_type)
- self.rpn += op;
- # print "**prec1_expr4 %s" % arg_type
- else:
- break
-
-
- def prec2_expr(self,
- arg_type
- ):
-
- pass
- self.prec3_expr(arg_type)
- while True:
- if (self.LA(1)==MUL or self.LA(1)==DIV):
- pass
- la1 = self.LA(1)
- if False:
- pass
- elif la1 and la1 in [MUL]:
- pass
- self.match(MUL)
- op = struct.pack('B', ptgMul)
- elif la1 and la1 in [DIV]:
- pass
- self.match(DIV)
- op = struct.pack('B', ptgDiv)
- else:
- raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
- self.prec3_expr(arg_type)
- self.rpn += op
- else:
- break
-
-
- def prec3_expr(self,
- arg_type
- ):
-
- pass
- self.prec4_expr(arg_type)
- while True:
- if (self.LA(1)==POWER):
- pass
- pass
- self.match(POWER)
- op = struct.pack('B', ptgPower)
- self.prec4_expr(arg_type)
- self.rpn += op
- else:
- break
-
-
- def prec4_expr(self,
- arg_type
- ):
-
- pass
- self.prec5_expr(arg_type)
- la1 = self.LA(1)
- if False:
- pass
- elif la1 and la1 in [PERCENT]:
- pass
- self.match(PERCENT)
- self.rpn += struct.pack('B', ptgPercent)
- elif la1 and la1 in [EOF,EQ,NE,GT,LT,GE,LE,ADD,SUB,MUL,DIV,POWER,RP,COMMA,SEMICOLON,CONCAT]:
- pass
- else:
- raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
-
- def prec5_expr(self,
- arg_type
- ):
-
- la1 = self.LA(1)
- if False:
- pass
- elif la1 and la1 in [TRUE_CONST,FALSE_CONST,STR_CONST,NUM_CONST,INT_CONST,FUNC_IF,FUNC_CHOOSE,NAME,QUOTENAME,LP,REF2D]:
- pass
- self.primary(arg_type)
- elif la1 and la1 in [SUB]:
- pass
- self.match(SUB)
- self.primary(arg_type)
- self.rpn += struct.pack('B', ptgUminus)
- else:
- raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
-
- def primary(self,
- arg_type
- ):
-
- str_tok = None
- int_tok = None
- num_tok = None
- ref2d_tok = None
- ref2d1_tok = None
- ref2d2_tok = None
- ref3d_ref2d = None
- ref3d_ref2d2 = None
- name_tok = None
- func_tok = None
- la1 = self.LA(1)
- if False:
- pass
- elif la1 and la1 in [TRUE_CONST]:
- pass
- self.match(TRUE_CONST)
- self.rpn += struct.pack("2B", ptgBool, 1)
- elif la1 and la1 in [FALSE_CONST]:
- pass
- self.match(FALSE_CONST)
- self.rpn += struct.pack("2B", ptgBool, 0)
- elif la1 and la1 in [STR_CONST]:
- pass
- str_tok = self.LT(1)
- self.match(STR_CONST)
- self.rpn += struct.pack("B", ptgStr) + upack1(str_tok.text[1:-1].replace("\"\"", "\""))
- elif la1 and la1 in [NUM_CONST]:
- pass
- num_tok = self.LT(1)
- self.match(NUM_CONST)
- self.rpn += struct.pack("<Bd", ptgNum, float(num_tok.text))
- elif la1 and la1 in [FUNC_IF]:
- pass
- self.match(FUNC_IF)
- self.match(LP)
- self.expr("V")
- la1 = self.LA(1)
- if False:
- pass
- elif la1 and la1 in [SEMICOLON]:
- pass
- self.match(SEMICOLON)
- elif la1 and la1 in [COMMA]:
- pass
- self.match(COMMA)
- else:
- raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
- self.rpn += struct.pack("<BBH", ptgAttr, 0x02, 0) # tAttrIf
- pos0 = len(self.rpn) - 2
- self.expr(arg_type)
- la1 = self.LA(1)
- if False:
- pass
- elif la1 and la1 in [SEMICOLON]:
- pass
- self.match(SEMICOLON)
- elif la1 and la1 in [COMMA]:
- pass
- self.match(COMMA)
- else:
- raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
- self.rpn += struct.pack("<BBH", ptgAttr, 0x08, 0) # tAttrSkip
- pos1 = len(self.rpn) - 2
- self.rpn = self.rpn[:pos0] + struct.pack("<H", pos1-pos0) + self.rpn[pos0+2:]
- self.expr(arg_type)
- self.match(RP)
- self.rpn += struct.pack("<BBH", ptgAttr, 0x08, 3) # tAttrSkip
- self.rpn += struct.pack("<BBH", ptgFuncVarR, 3, 1) # 3 = nargs, 1 = IF func
- pos2 = len(self.rpn)
- self.rpn = self.rpn[:pos1] + struct.pack("<H", pos2-(pos1+2)-1) + self.rpn[pos1+2:]
- elif la1 and la1 in [FUNC_CHOOSE]:
- pass
- self.match(FUNC_CHOOSE)
- arg_type = "R"
- rpn_chunks = []
- self.match(LP)
- self.expr("V")
- rpn_start = len(self.rpn)
- ref_markers = [len(self.sheet_references)]
- while True:
- if (self.LA(1)==COMMA or self.LA(1)==SEMICOLON):
- pass
- la1 = self.LA(1)
- if False:
- pass
- elif la1 and la1 in [SEMICOLON]:
- pass
- self.match(SEMICOLON)
- elif la1 and la1 in [COMMA]:
- pass
- self.match(COMMA)
- else:
- raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
- mark = len(self.rpn)
- la1 = self.LA(1)
- if False:
- pass
- elif la1 and la1 in [TRUE_CONST,FALSE_CONST,STR_CONST,NUM_CONST,INT_CONST,FUNC_IF,FUNC_CHOOSE,NAME,QUOTENAME,SUB,LP,REF2D]:
- pass
- self.expr(arg_type)
- elif la1 and la1 in [RP,COMMA,SEMICOLON]:
- pass
- self.rpn += struct.pack("B", ptgMissArg)
- else:
- raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
- rpn_chunks.append(self.rpn[mark:])
- ref_markers.append(len(self.sheet_references))
- else:
- break
-
- self.match(RP)
- self.rpn = self.rpn[:rpn_start]
- nc = len(rpn_chunks)
- chunklens = [len(chunk) for chunk in rpn_chunks]
- skiplens = [0] * nc
- skiplens[-1] = 3
- for ic in xrange(nc-1, 0, -1):
- skiplens[ic-1] = skiplens[ic] + chunklens[ic] + 4
- jump_pos = [2 * nc + 2]
- for ic in xrange(nc):
- jump_pos.append(jump_pos[-1] + chunklens[ic] + 4)
- chunk_shift = 2 * nc + 6 # size of tAttrChoose
- for ic in xrange(nc):
- for refx in xrange(ref_markers[ic], ref_markers[ic+1]):
- ref = self.sheet_references[refx]
- self.sheet_references[refx] = (ref[0], ref[1], ref[2] + chunk_shift)
- chunk_shift += 4 # size of tAttrSkip
- choose_rpn = []
- choose_rpn.append(struct.pack("<BBH", ptgAttr, 0x04, nc)) # 0x04 is tAttrChoose
- choose_rpn.append(struct.pack("<%dH" % (nc+1), *jump_pos))
- for ic in xrange(nc):
- choose_rpn.append(rpn_chunks[ic])
- choose_rpn.append(struct.pack("<BBH", ptgAttr, 0x08, skiplens[ic])) # 0x08 is tAttrSkip
- choose_rpn.append(struct.pack("<BBH", ptgFuncVarV, nc+1, 100)) # 100 is CHOOSE fn
- self.rpn += "".join(choose_rpn)
- elif la1 and la1 in [LP]:
- pass
- self.match(LP)
- self.expr(arg_type)
- self.match(RP)
- self.rpn += struct.pack("B", ptgParen)
- else:
- if (self.LA(1)==INT_CONST) and (_tokenSet_0.member(self.LA(2))):
- pass
- int_tok = self.LT(1)
- self.match(INT_CONST)
- # print "**int_const", int_tok.text
- int_value = int(int_tok.text)
- if int_value <= 65535:
- self.rpn += struct.pack("<BH", ptgInt, int_value)
- else:
- self.rpn += struct.pack("<Bd", ptgNum, float(int_value))
- elif (self.LA(1)==REF2D) and (_tokenSet_0.member(self.LA(2))):
- pass
- ref2d_tok = self.LT(1)
- self.match(REF2D)
- # print "**ref2d %s %s" % (ref2d_tok.text, arg_type)
- r, c = Utils.cell_to_packed_rowcol(ref2d_tok.text)
- ptg = ptgRefR + _RVAdeltaRef[arg_type]
- self.rpn += struct.pack("<B2H", ptg, r, c)
- elif (self.LA(1)==REF2D) and (self.LA(2)==COLON):
- pass
- ref2d1_tok = self.LT(1)
- self.match(REF2D)
- self.match(COLON)
- ref2d2_tok = self.LT(1)
- self.match(REF2D)
- r1, c1 = Utils.cell_to_packed_rowcol(ref2d1_tok.text)
- r2, c2 = Utils.cell_to_packed_rowcol(ref2d2_tok.text)
- ptg = ptgAreaR + _RVAdeltaArea[arg_type]
- self.rpn += struct.pack("<B4H", ptg, r1, r2, c1, c2)
- elif (self.LA(1)==INT_CONST or self.LA(1)==NAME or self.LA(1)==QUOTENAME) and (self.LA(2)==COLON or self.LA(2)==BANG):
- pass
- sheet1=self.sheet()
- sheet2 = sheet1
- la1 = self.LA(1)
- if False:
- pass
- elif la1 and la1 in [COLON]:
- pass
- self.match(COLON)
- sheet2=self.sheet()
- elif la1 and la1 in [BANG]:
- pass
- else:
- raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
- self.match(BANG)
- ref3d_ref2d = self.LT(1)
- self.match(REF2D)
- ptg = ptgRef3dR + _RVAdeltaRef[arg_type]
- rpn_ref2d = ""
- r1, c1 = Utils.cell_to_packed_rowcol(ref3d_ref2d.text)
- rpn_ref2d = struct.pack("<3H", 0x0000, r1, c1)
- la1 = self.LA(1)
- if False:
- pass
- elif la1 and la1 in [COLON]:
- pass
- self.match(COLON)
- ref3d_ref2d2 = self.LT(1)
- self.match(REF2D)
- ptg = ptgArea3dR + _RVAdeltaArea[arg_type]
- r2, c2 = Utils.cell_to_packed_rowcol(ref3d_ref2d2.text)
- rpn_ref2d = struct.pack("<5H", 0x0000, r1, r2, c1, c2)
- elif la1 and la1 in [EOF,EQ,NE,GT,LT,GE,LE,ADD,SUB,MUL,DIV,POWER,PERCENT,RP,COMMA,SEMICOLON,CONCAT]:
- pass
- else:
- raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
- self.rpn += struct.pack("<B", ptg)
- self.sheet_references.append((sheet1, sheet2, len(self.rpn)))
- self.rpn += rpn_ref2d
- elif (self.LA(1)==NAME) and (_tokenSet_0.member(self.LA(2))):
- pass
- name_tok = self.LT(1)
- self.match(NAME)
- raise Exception("[formula] found unexpected NAME token (%r)" % name_tok.txt)
- # #### TODO: handle references to defined names here
- elif (self.LA(1)==NAME) and (self.LA(2)==LP):
- pass
- func_tok = self.LT(1)
- self.match(NAME)
- func_toku = func_tok.text.upper()
- if func_toku in all_funcs_by_name:
- (opcode,
- min_argc,
- max_argc,
- func_type,
- arg_type_str) = all_funcs_by_name[func_toku]
- arg_type_list = list(arg_type_str)
- else:
- raise Exception("[formula] unknown function (%s)" % func_tok.text)
- # print "**func_tok1 %s %s" % (func_toku, func_type)
- xcall = opcode < 0
- if xcall:
- # The name of the add-in function is passed as the 1st arg
- # of the hidden XCALL function
- self.xcall_references.append((func_toku, len(self.rpn) + 1))
- self.rpn += struct.pack("<BHHH",
- ptgNameXR,
- 0xadde, # ##PATCHME## index to REF entry in EXTERNSHEET record
- 0xefbe, # ##PATCHME## one-based index to EXTERNNAME record
- 0x0000) # unused
- self.match(LP)
- arg_count=self.expr_list(arg_type_list, min_argc, max_argc)
- self.match(RP)
- if arg_count > max_argc or arg_count < min_argc:
- raise Exception, "%d parameters for function: %s" % (arg_count, func_tok.text)
- if xcall:
- func_ptg = ptgFuncVarR + _RVAdelta[func_type]
- self.rpn += struct.pack("<2BH", func_ptg, arg_count + 1, 255) # 255 is magic XCALL function
- elif min_argc == max_argc:
- func_ptg = ptgFuncR + _RVAdelta[func_type]
- self.rpn += struct.pack("<BH", func_ptg, opcode)
- elif arg_count == 1 and func_tok.text.upper() == "SUM":
- self.rpn += struct.pack("<BBH", ptgAttr, 0x10, 0) # tAttrSum
- else:
- func_ptg = ptgFuncVarR + _RVAdelta[func_type]
- self.rpn += struct.pack("<2BH", func_ptg, arg_count, opcode)
- else:
- raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
-
- def sheet(self):
- ref = None
-
- sheet_ref_name = None
- sheet_ref_int = None
- sheet_ref_quote = None
- la1 = self.LA(1)
- if False:
- pass
- elif la1 and la1 in [NAME]:
- pass
- sheet_ref_name = self.LT(1)
- self.match(NAME)
- ref = sheet_ref_name.text
- elif la1 and la1 in [INT_CONST]:
- pass
- sheet_ref_int = self.LT(1)
- self.match(INT_CONST)
- ref = sheet_ref_int.text
- elif la1 and la1 in [QUOTENAME]:
- pass
- sheet_ref_quote = self.LT(1)
- self.match(QUOTENAME)
- ref = sheet_ref_quote.text[1:-1].replace("''", "'")
- else:
- raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
- return ref
-
- def expr_list(self,
- arg_type_list, min_argc, max_argc
- ):
- arg_cnt = None
-
- arg_cnt = 0
- arg_type = arg_type_list[arg_cnt]
- # print "**expr_list1[%d] req=%s" % (arg_cnt, arg_type)
- la1 = self.LA(1)
- if False:
- pass
- elif la1 and la1 in [TRUE_CONST,FALSE_CONST,STR_CONST,NUM_CONST,INT_CONST,FUNC_IF,FUNC_CHOOSE,NAME,QUOTENAME,SUB,LP,REF2D]:
- pass
- self.expr(arg_type)
- arg_cnt += 1
- while True:
- if (self.LA(1)==COMMA or self.LA(1)==SEMICOLON):
- pass
- if arg_cnt < len(arg_type_list):
- arg_type = arg_type_list[arg_cnt]
- else:
- arg_type = arg_type_list[-1]
- if arg_type == "+":
- arg_type = arg_type_list[-2]
- # print "**expr_list2[%d] req=%s" % (arg_cnt, arg_type)
- la1 = self.LA(1)
- if False:
- pass
- elif la1 and la1 in [SEMICOLON]:
- pass
- self.match(SEMICOLON)
- elif la1 and la1 in [COMMA]:
- pass
- self.match(COMMA)
- else:
- raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
- la1 = self.LA(1)
- if False:
- pass
- elif la1 and la1 in [TRUE_CONST,FALSE_CONST,STR_CONST,NUM_CONST,INT_CONST,FUNC_IF,FUNC_CHOOSE,NAME,QUOTENAME,SUB,LP,REF2D]:
- pass
- self.expr(arg_type)
- elif la1 and la1 in [RP,COMMA,SEMICOLON]:
- pass
- self.rpn += struct.pack("B", ptgMissArg)
- else:
- raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
- arg_cnt += 1
- else:
- break
-
- elif la1 and la1 in [RP]:
- pass
- else:
- raise antlr.NoViableAltException(self.LT(1), self.getFilename())
-
- return arg_cnt
-
-
-_tokenNames = [
- "<0>",
- "EOF",
- "<2>",
- "NULL_TREE_LOOKAHEAD",
- "TRUE_CONST",
- "FALSE_CONST",
- "STR_CONST",
- "NUM_CONST",
- "INT_CONST",
- "FUNC_IF",
- "FUNC_CHOOSE",
- "NAME",
- "QUOTENAME",
- "EQ",
- "NE",
- "GT",
- "LT",
- "GE",
- "LE",
- "ADD",
- "SUB",
- "MUL",
- "DIV",
- "POWER",
- "PERCENT",
- "LP",
- "RP",
- "LB",
- "RB",
- "COLON",
- "COMMA",
- "SEMICOLON",
- "REF2D",
- "REF2D_R1C1",
- "BANG",
- "CONCAT"
-]
-
-
-### generate bit set
-def mk_tokenSet_0():
- ### var1
- data = [ 37681618946L, 0L]
- return data
-_tokenSet_0 = antlr.BitSet(mk_tokenSet_0())
-
diff --git a/tablib/packages/xlwt/ExcelMagic.py b/tablib/packages/xlwt/ExcelMagic.py deleted file mode 100644 index a0a287c..0000000 --- a/tablib/packages/xlwt/ExcelMagic.py +++ /dev/null @@ -1,862 +0,0 @@ -# -*- coding: ascii -*-
-"""
-lots of Excel Magic Numbers
-"""
-
-# Boundaries BIFF8+
-
-MAX_ROW = 65536
-MAX_COL = 256
-
-
-biff_records = {
- 0x0000: "DIMENSIONS",
- 0x0001: "BLANK",
- 0x0002: "INTEGER",
- 0x0003: "NUMBER",
- 0x0004: "LABEL",
- 0x0005: "BOOLERR",
- 0x0006: "FORMULA",
- 0x0007: "STRING",
- 0x0008: "ROW",
- 0x0009: "BOF",
- 0x000A: "EOF",
- 0x000B: "INDEX",
- 0x000C: "CALCCOUNT",
- 0x000D: "CALCMODE",
- 0x000E: "PRECISION",
- 0x000F: "REFMODE",
- 0x0010: "DELTA",
- 0x0011: "ITERATION",
- 0x0012: "PROTECT",
- 0x0013: "PASSWORD",
- 0x0014: "HEADER",
- 0x0015: "FOOTER",
- 0x0016: "EXTERNCOUNT",
- 0x0017: "EXTERNSHEET",
- 0x0018: "NAME",
- 0x0019: "WINDOWPROTECT",
- 0x001A: "VERTICALPAGEBREAKS",
- 0x001B: "HORIZONTALPAGEBREAKS",
- 0x001C: "NOTE",
- 0x001D: "SELECTION",
- 0x001E: "FORMAT",
- 0x001F: "FORMATCOUNT",
- 0x0020: "COLUMNDEFAULT",
- 0x0021: "ARRAY",
- 0x0022: "1904",
- 0x0023: "EXTERNNAME",
- 0x0024: "COLWIDTH",
- 0x0025: "DEFAULTROWHEIGHT",
- 0x0026: "LEFTMARGIN",
- 0x0027: "RIGHTMARGIN",
- 0x0028: "TOPMARGIN",
- 0x0029: "BOTTOMMARGIN",
- 0x002A: "PRINTHEADERS",
- 0x002B: "PRINTGRIDLINES",
- 0x002F: "FILEPASS",
- 0x0031: "FONT",
- 0x0036: "TABLE",
- 0x003C: "CONTINUE",
- 0x003D: "WINDOW1",
- 0x003E: "WINDOW2",
- 0x0040: "BACKUP",
- 0x0041: "PANE",
- 0x0042: "CODEPAGE",
- 0x0043: "XF",
- 0x0044: "IXFE",
- 0x0045: "EFONT",
- 0x004D: "PLS",
- 0x0050: "DCON",
- 0x0051: "DCONREF",
- 0x0053: "DCONNAME",
- 0x0055: "DEFCOLWIDTH",
- 0x0056: "BUILTINFMTCNT",
- 0x0059: "XCT",
- 0x005A: "CRN",
- 0x005B: "FILESHARING",
- 0x005C: "WRITEACCESS",
- 0x005D: "OBJ",
- 0x005E: "UNCALCED",
- 0x005F: "SAFERECALC",
- 0x0060: "TEMPLATE",
- 0x0063: "OBJPROTECT",
- 0x007D: "COLINFO",
- 0x007E: "RK",
- 0x007F: "IMDATA",
- 0x0080: "GUTS",
- 0x0081: "WSBOOL",
- 0x0082: "GRIDSET",
- 0x0083: "HCENTER",
- 0x0084: "VCENTER",
- 0x0085: "BOUNDSHEET",
- 0x0086: "WRITEPROT",
- 0x0087: "ADDIN",
- 0x0088: "EDG",
- 0x0089: "PUB",
- 0x008C: "COUNTRY",
- 0x008D: "HIDEOBJ",
- 0x008E: "BUNDLESOFFSET",
- 0x008F: "BUNDLEHEADER",
- 0x0090: "SORT",
- 0x0091: "SUB",
- 0x0092: "PALETTE",
- 0x0093: "STYLE",
- 0x0094: "LHRECORD",
- 0x0095: "LHNGRAPH",
- 0x0096: "SOUND",
- 0x0098: "LPR",
- 0x0099: "STANDARDWIDTH",
- 0x009A: "FNGROUPNAME",
- 0x009B: "FILTERMODE",
- 0x009C: "FNGROUPCOUNT",
- 0x009D: "AUTOFILTERINFO",
- 0x009E: "AUTOFILTER",
- 0x00A0: "SCL",
- 0x00A1: "SETUP",
- 0x00A9: "COORDLIST",
- 0x00AB: "GCW",
- 0x00AE: "SCENMAN",
- 0x00AF: "SCENARIO",
- 0x00B0: "SXVIEW",
- 0x00B1: "SXVD",
- 0x00B2: "SXVI",
- 0x00B4: "SXIVD",
- 0x00B5: "SXLI",
- 0x00B6: "SXPI",
- 0x00B8: "DOCROUTE",
- 0x00B9: "RECIPNAME",
- 0x00BC: "SHRFMLA",
- 0x00BD: "MULRK",
- 0x00BE: "MULBLANK",
- 0x00C1: "MMS",
- 0x00C2: "ADDMENU",
- 0x00C3: "DELMENU",
- 0x00C5: "SXDI",
- 0x00C6: "SXDB",
- 0x00C7: "SXFIELD",
- 0x00C8: "SXINDEXLIST",
- 0x00C9: "SXDOUBLE",
- 0x00CD: "SXSTRING",
- 0x00CE: "SXDATETIME",
- 0x00D0: "SXTBL",
- 0x00D1: "SXTBRGITEM",
- 0x00D2: "SXTBPG",
- 0x00D3: "OBPROJ",
- 0x00D5: "SXIDSTM",
- 0x00D6: "RSTRING",
- 0x00D7: "DBCELL",
- 0x00DA: "BOOKBOOL",
- 0x00DC: "SXEXT|PARAMQRY",
- 0x00DD: "SCENPROTECT",
- 0x00DE: "OLESIZE",
- 0x00DF: "UDDESC",
- 0x00E0: "XF",
- 0x00E1: "INTERFACEHDR",
- 0x00E2: "INTERFACEEND",
- 0x00E3: "SXVS",
- 0x00E5: "MERGEDCELLS",
- 0x00E9: "BITMAP",
- 0x00EB: "MSODRAWINGGROUP",
- 0x00EC: "MSODRAWING",
- 0x00ED: "MSODRAWINGSELECTION",
- 0x00F0: "SXRULE",
- 0x00F1: "SXEX",
- 0x00F2: "SXFILT",
- 0x00F6: "SXNAME",
- 0x00F7: "SXSELECT",
- 0x00F8: "SXPAIR",
- 0x00F9: "SXFMLA",
- 0x00FB: "SXFORMAT",
- 0x00FC: "SST",
- 0x00FD: "LABELSST",
- 0x00FF: "EXTSST",
- 0x0100: "SXVDEX",
- 0x0103: "SXFORMULA",
- 0x0122: "SXDBEX",
- 0x0137: "CHTRINSERT",
- 0x0138: "CHTRINFO",
- 0x013B: "CHTRCELLCONTENT",
- 0x013D: "TABID",
- 0x0140: "CHTRMOVERANGE",
- 0x014D: "CHTRINSERTTAB",
- 0x015F: "LABELRANGES",
- 0x0160: "USESELFS",
- 0x0161: "DSF",
- 0x0162: "XL5MODIFY",
- 0x0196: "CHTRHEADER",
- 0x01A9: "USERBVIEW",
- 0x01AA: "USERSVIEWBEGIN",
- 0x01AB: "USERSVIEWEND",
- 0x01AD: "QSI",
- 0x01AE: "SUPBOOK",
- 0x01AF: "PROT4REV",
- 0x01B0: "CONDFMT",
- 0x01B1: "CF",
- 0x01B2: "DVAL",
- 0x01B5: "DCONBIN",
- 0x01B6: "TXO",
- 0x01B7: "REFRESHALL",
- 0x01B8: "HLINK",
- 0x01BA: "CODENAME",
- 0x01BB: "SXFDBTYPE",
- 0x01BC: "PROT4REVPASS",
- 0x01BE: "DV",
- 0x01C0: "XL9FILE",
- 0x01C1: "RECALCID",
- 0x0200: "DIMENSIONS",
- 0x0201: "BLANK",
- 0x0203: "NUMBER",
- 0x0204: "LABEL",
- 0x0205: "BOOLERR",
- 0x0206: "FORMULA",
- 0x0207: "STRING",
- 0x0208: "ROW",
- 0x0209: "BOF",
- 0x020B: "INDEX",
- 0x0218: "NAME",
- 0x0221: "ARRAY",
- 0x0223: "EXTERNNAME",
- 0x0225: "DEFAULTROWHEIGHT",
- 0x0231: "FONT",
- 0x0236: "TABLE",
- 0x023E: "WINDOW2",
- 0x0243: "XF",
- 0x027E: "RK",
- 0x0293: "STYLE",
- 0x0406: "FORMULA",
- 0x0409: "BOF",
- 0x041E: "FORMAT",
- 0x0443: "XF",
- 0x04BC: "SHRFMLA",
- 0x0800: "SCREENTIP",
- 0x0803: "WEBQRYSETTINGS",
- 0x0804: "WEBQRYTABLES",
- 0x0809: "BOF",
- 0x0862: "SHEETLAYOUT",
- 0x0867: "SHEETPROTECTION",
- 0x1001: "UNITS",
- 0x1002: "ChartChart",
- 0x1003: "ChartSeries",
- 0x1006: "ChartDataformat",
- 0x1007: "ChartLineformat",
- 0x1009: "ChartMarkerformat",
- 0x100A: "ChartAreaformat",
- 0x100B: "ChartPieformat",
- 0x100C: "ChartAttachedlabel",
- 0x100D: "ChartSeriestext",
- 0x1014: "ChartChartformat",
- 0x1015: "ChartLegend",
- 0x1016: "ChartSerieslist",
- 0x1017: "ChartBar",
- 0x1018: "ChartLine",
- 0x1019: "ChartPie",
- 0x101A: "ChartArea",
- 0x101B: "ChartScatter",
- 0x101C: "ChartChartline",
- 0x101D: "ChartAxis",
- 0x101E: "ChartTick",
- 0x101F: "ChartValuerange",
- 0x1020: "ChartCatserrange",
- 0x1021: "ChartAxislineformat",
- 0x1022: "ChartFormatlink",
- 0x1024: "ChartDefaulttext",
- 0x1025: "ChartText",
- 0x1026: "ChartFontx",
- 0x1027: "ChartObjectLink",
- 0x1032: "ChartFrame",
- 0x1033: "BEGIN",
- 0x1034: "END",
- 0x1035: "ChartPlotarea",
- 0x103A: "Chart3D",
- 0x103C: "ChartPicf",
- 0x103D: "ChartDropbar",
- 0x103E: "ChartRadar",
- 0x103F: "ChartSurface",
- 0x1040: "ChartRadararea",
- 0x1041: "ChartAxisparent",
- 0x1043: "ChartLegendxn",
- 0x1044: "ChartShtprops",
- 0x1045: "ChartSertocrt",
- 0x1046: "ChartAxesused",
- 0x1048: "ChartSbaseref",
- 0x104A: "ChartSerparent",
- 0x104B: "ChartSerauxtrend",
- 0x104E: "ChartIfmt",
- 0x104F: "ChartPos",
- 0x1050: "ChartAlruns",
- 0x1051: "ChartAI",
- 0x105B: "ChartSerauxerrbar",
- 0x105D: "ChartSerfmt",
- 0x105F: "Chart3DDataFormat",
- 0x1060: "ChartFbi",
- 0x1061: "ChartBoppop",
- 0x1062: "ChartAxcext",
- 0x1063: "ChartDat",
- 0x1064: "ChartPlotgrowth",
- 0x1065: "ChartSiindex",
- 0x1066: "ChartGelframe",
- 0x1067: "ChartBoppcustom",
- 0xFFFF: ""
-}
-
-
-all_funcs_by_name = {
- # Includes Analysis ToolPak aka ATP aka add-in aka xcall functions,
- # distinguished by -ve opcode.
- # name: (opcode, min # args, max # args, func return type, func arg types)
- # + in func arg types means more of the same.
- 'ABS' : ( 24, 1, 1, 'V', 'V'),
- 'ACCRINT' : ( -1, 6, 7, 'V', 'VVVVVVV'),
- 'ACCRINTM' : ( -1, 3, 5, 'V', 'VVVVV'),
- 'ACOS' : ( 99, 1, 1, 'V', 'V'),
- 'ACOSH' : (233, 1, 1, 'V', 'V'),
- 'ADDRESS' : (219, 2, 5, 'V', 'VVVVV'),
- 'AMORDEGRC' : ( -1, 7, 7, 'V', 'VVVVVVV'),
- 'AMORLINC' : ( -1, 7, 7, 'V', 'VVVVVVV'),
- 'AND' : ( 36, 1, 30, 'V', 'D+'),
- 'AREAS' : ( 75, 1, 1, 'V', 'R'),
- 'ASC' : (214, 1, 1, 'V', 'V'),
- 'ASIN' : ( 98, 1, 1, 'V', 'V'),
- 'ASINH' : (232, 1, 1, 'V', 'V'),
- 'ATAN' : ( 18, 1, 1, 'V', 'V'),
- 'ATAN2' : ( 97, 2, 2, 'V', 'VV'),
- 'ATANH' : (234, 1, 1, 'V', 'V'),
- 'AVEDEV' : (269, 1, 30, 'V', 'D+'),
- 'AVERAGE' : ( 5, 1, 30, 'V', 'D+'),
- 'AVERAGEA' : (361, 1, 30, 'V', 'D+'),
- 'BAHTTEXT' : (368, 1, 1, 'V', 'V'),
- 'BESSELI' : ( -1, 2, 2, 'V', 'VV'),
- 'BESSELJ' : ( -1, 2, 2, 'V', 'VV'),
- 'BESSELK' : ( -1, 2, 2, 'V', 'VV'),
- 'BESSELY' : ( -1, 2, 2, 'V', 'VV'),
- 'BETADIST' : (270, 3, 5, 'V', 'VVVVV'),
- 'BETAINV' : (272, 3, 5, 'V', 'VVVVV'),
- 'BIN2DEC' : ( -1, 1, 1, 'V', 'V'),
- 'BIN2HEX' : ( -1, 1, 2, 'V', 'VV'),
- 'BIN2OCT' : ( -1, 1, 2, 'V', 'VV'),
- 'BINOMDIST' : (273, 4, 4, 'V', 'VVVV'),
- 'CEILING' : (288, 2, 2, 'V', 'VV'),
- 'CELL' : (125, 1, 2, 'V', 'VR'),
- 'CHAR' : (111, 1, 1, 'V', 'V'),
- 'CHIDIST' : (274, 2, 2, 'V', 'VV'),
- 'CHIINV' : (275, 2, 2, 'V', 'VV'),
- 'CHITEST' : (306, 2, 2, 'V', 'AA'),
- 'CHOOSE' : (100, 2, 30, 'R', 'VR+'),
- 'CLEAN' : (162, 1, 1, 'V', 'V'),
- 'CODE' : (121, 1, 1, 'V', 'V'),
- 'COLUMN' : ( 9, 0, 1, 'V', 'R'),
- 'COLUMNS' : ( 77, 1, 1, 'V', 'R'),
- 'COMBIN' : (276, 2, 2, 'V', 'VV'),
- 'COMPLEX' : ( -1, 2, 3, 'V', 'VVV'),
- 'CONCATENATE' : (336, 1, 30, 'V', 'V+'),
- 'CONFIDENCE' : (277, 3, 3, 'V', 'VVV'),
- 'CONVERT' : ( -1, 3, 3, 'V', 'VVV'),
- 'CORREL' : (307, 2, 2, 'V', 'AA'),
- 'COS' : ( 16, 1, 1, 'V', 'V'),
- 'COSH' : (230, 1, 1, 'V', 'V'),
- 'COUNT' : ( 0, 1, 30, 'V', 'D+'),
- 'COUNTA' : (169, 1, 30, 'V', 'D+'),
- 'COUNTBLANK' : (347, 1, 1, 'V', 'R'),
- 'COUNTIF' : (346, 2, 2, 'V', 'RV'),
- 'COUPDAYBS' : ( -1, 3, 5, 'V', 'VVVVV'),
- 'COUPDAYS' : ( -1, 3, 5, 'V', 'VVVVV'),
- 'COUPDAYSNC' : ( -1, 3, 5, 'V', 'VVVVV'),
- 'COUPNCD' : ( -1, 3, 5, 'V', 'VVVVV'),
- 'COUPNUM' : ( -1, 3, 5, 'V', 'VVVVV'),
- 'COUPPCD' : ( -1, 3, 5, 'V', 'VVVVV'),
- 'COVAR' : (308, 2, 2, 'V', 'AA'),
- 'CRITBINOM' : (278, 3, 3, 'V', 'VVV'),
- 'CUMIPMT' : ( -1, 6, 6, 'V', 'VVVVVV'),
- 'CUMPRINC' : ( -1, 6, 6, 'V', 'VVVVVV'),
- 'DATE' : ( 65, 3, 3, 'V', 'VVV'),
- 'DATEDIF' : (351, 3, 3, 'V', 'VVV'),
- 'DATEVALUE' : (140, 1, 1, 'V', 'V'),
- 'DAVERAGE' : ( 42, 3, 3, 'V', 'RRR'),
- 'DAY' : ( 67, 1, 1, 'V', 'V'),
- 'DAYS360' : (220, 2, 3, 'V', 'VVV'),
- 'DB' : (247, 4, 5, 'V', 'VVVVV'),
- 'DBCS' : (215, 1, 1, 'V', 'V'),
- 'DCOUNT' : ( 40, 3, 3, 'V', 'RRR'),
- 'DCOUNTA' : (199, 3, 3, 'V', 'RRR'),
- 'DDB' : (144, 4, 5, 'V', 'VVVVV'),
- 'DEC2BIN' : ( -1, 1, 2, 'V', 'VV'),
- 'DEC2HEX' : ( -1, 1, 2, 'V', 'VV'),
- 'DEC2OCT' : ( -1, 1, 2, 'V', 'VV'),
- 'DEGREES' : (343, 1, 1, 'V', 'V'),
- 'DELTA' : ( -1, 1, 2, 'V', 'VV'),
- 'DEVSQ' : (318, 1, 30, 'V', 'D+'),
- 'DGET' : (235, 3, 3, 'V', 'RRR'),
- 'DISC' : ( -1, 4, 5, 'V', 'VVVVV'),
- 'DMAX' : ( 44, 3, 3, 'V', 'RRR'),
- 'DMIN' : ( 43, 3, 3, 'V', 'RRR'),
- 'DOLLAR' : ( 13, 1, 2, 'V', 'VV'),
- 'DOLLARDE' : ( -1, 2, 2, 'V', 'VV'),
- 'DOLLARFR' : ( -1, 2, 2, 'V', 'VV'),
- 'DPRODUCT' : (189, 3, 3, 'V', 'RRR'),
- 'DSTDEV' : ( 45, 3, 3, 'V', 'RRR'),
- 'DSTDEVP' : (195, 3, 3, 'V', 'RRR'),
- 'DSUM' : ( 41, 3, 3, 'V', 'RRR'),
- 'DURATION' : ( -1, 5, 6, 'V', 'VVVVVV'),
- 'DVAR' : ( 47, 3, 3, 'V', 'RRR'),
- 'DVARP' : (196, 3, 3, 'V', 'RRR'),
- 'EDATE' : ( -1, 2, 2, 'V', 'VV'),
- 'EFFECT' : ( -1, 2, 2, 'V', 'VV'),
- 'EOMONTH' : ( -1, 1, 2, 'V', 'VV'),
- 'ERF' : ( -1, 1, 2, 'V', 'VV'),
- 'ERFC' : ( -1, 1, 1, 'V', 'V'),
- 'ERROR.TYPE' : (261, 1, 1, 'V', 'V'),
- 'EVEN' : (279, 1, 1, 'V', 'V'),
- 'EXACT' : (117, 2, 2, 'V', 'VV'),
- 'EXP' : ( 21, 1, 1, 'V', 'V'),
- 'EXPONDIST' : (280, 3, 3, 'V', 'VVV'),
- 'FACT' : (184, 1, 1, 'V', 'V'),
- 'FACTDOUBLE' : ( -1, 1, 1, 'V', 'V'),
- 'FALSE' : ( 35, 0, 0, 'V', '-'),
- 'FDIST' : (281, 3, 3, 'V', 'VVV'),
- 'FIND' : (124, 2, 3, 'V', 'VVV'),
- 'FINDB' : (205, 2, 3, 'V', 'VVV'),
- 'FINV' : (282, 3, 3, 'V', 'VVV'),
- 'FISHER' : (283, 1, 1, 'V', 'V'),
- 'FISHERINV' : (284, 1, 1, 'V', 'V'),
- 'FIXED' : ( 14, 2, 3, 'V', 'VVV'),
- 'FLOOR' : (285, 2, 2, 'V', 'VV'),
- 'FORECAST' : (309, 3, 3, 'V', 'VAA'),
- 'FREQUENCY' : (252, 2, 2, 'A', 'RR'),
- 'FTEST' : (310, 2, 2, 'V', 'AA'),
- 'FV' : ( 57, 3, 5, 'V', 'VVVVV'),
- 'FVSCHEDULE' : ( -1, 2, 2, 'V', 'VA'),
- 'GAMMADIST' : (286, 4, 4, 'V', 'VVVV'),
- 'GAMMAINV' : (287, 3, 3, 'V', 'VVV'),
- 'GAMMALN' : (271, 1, 1, 'V', 'V'),
- 'GCD' : ( -1, 1, 29, 'V', 'V+'),
- 'GEOMEAN' : (319, 1, 30, 'V', 'D+'),
- 'GESTEP' : ( -1, 1, 2, 'V', 'VV'),
- 'GETPIVOTDATA': (358, 2, 30, 'A', 'VAV+'),
- 'GROWTH' : ( 52, 1, 4, 'A', 'RRRV'),
- 'HARMEAN' : (320, 1, 30, 'V', 'D+'),
- 'HEX2BIN' : ( -1, 1, 2, 'V', 'VV'),
- 'HEX2DEC' : ( -1, 1, 1, 'V', 'V'),
- 'HEX2OCT' : ( -1, 1, 2, 'V', 'VV'),
- 'HLOOKUP' : (101, 3, 4, 'V', 'VRRV'),
- 'HOUR' : ( 71, 1, 1, 'V', 'V'),
- 'HYPERLINK' : (359, 1, 2, 'V', 'VV'),
- 'HYPGEOMDIST' : (289, 4, 4, 'V', 'VVVV'),
- 'IF' : ( 1, 2, 3, 'R', 'VRR'),
- 'IMABS' : ( -1, 1, 1, 'V', 'V'),
- 'IMAGINARY' : ( -1, 1, 1, 'V', 'V'),
- 'IMARGUMENT' : ( -1, 1, 1, 'V', 'V'),
- 'IMCONJUGATE' : ( -1, 1, 1, 'V', 'V'),
- 'IMCOS' : ( -1, 1, 1, 'V', 'V'),
- 'IMDIV' : ( -1, 2, 2, 'V', 'VV'),
- 'IMEXP' : ( -1, 1, 1, 'V', 'V'),
- 'IMLN' : ( -1, 1, 1, 'V', 'V'),
- 'IMLOG10' : ( -1, 1, 1, 'V', 'V'),
- 'IMLOG2' : ( -1, 1, 1, 'V', 'V'),
- 'IMPOWER' : ( -1, 2, 2, 'V', 'VV'),
- 'IMPRODUCT' : ( -1, 2, 2, 'V', 'VV'),
- 'IMREAL' : ( -1, 1, 1, 'V', 'V'),
- 'IMSIN' : ( -1, 1, 1, 'V', 'V'),
- 'IMSQRT' : ( -1, 1, 1, 'V', 'V'),
- 'IMSUB' : ( -1, 2, 2, 'V', 'VV'),
- 'IMSUM' : ( -1, 1, 29, 'V', 'V+'),
- 'INDEX' : ( 29, 2, 4, 'R', 'RVVV'),
- 'INDIRECT' : (148, 1, 2, 'R', 'VV'),
- 'INFO' : (244, 1, 1, 'V', 'V'),
- 'INT' : ( 25, 1, 1, 'V', 'V'),
- 'INTERCEPT' : (311, 2, 2, 'V', 'AA'),
- 'INTRATE' : ( -1, 4, 5, 'V', 'VVVVV'),
- 'IPMT' : (167, 4, 6, 'V', 'VVVVVV'),
- 'IRR' : ( 62, 1, 2, 'V', 'RV'),
- 'ISBLANK' : (129, 1, 1, 'V', 'V'),
- 'ISERR' : (126, 1, 1, 'V', 'V'),
- 'ISERROR' : ( 3, 1, 1, 'V', 'V'),
- 'ISEVEN' : ( -1, 1, 1, 'V', 'V'),
- 'ISLOGICAL' : (198, 1, 1, 'V', 'V'),
- 'ISNA' : ( 2, 1, 1, 'V', 'V'),
- 'ISNONTEXT' : (190, 1, 1, 'V', 'V'),
- 'ISNUMBER' : (128, 1, 1, 'V', 'V'),
- 'ISODD' : ( -1, 1, 1, 'V', 'V'),
- 'ISPMT' : (350, 4, 4, 'V', 'VVVV'),
- 'ISREF' : (105, 1, 1, 'V', 'R'),
- 'ISTEXT' : (127, 1, 1, 'V', 'V'),
- 'KURT' : (322, 1, 30, 'V', 'D+'),
- 'LARGE' : (325, 2, 2, 'V', 'RV'),
- 'LCM' : ( -1, 1, 29, 'V', 'V+'),
- 'LEFT' : (115, 1, 2, 'V', 'VV'),
- 'LEFTB' : (208, 1, 2, 'V', 'VV'),
- 'LEN' : ( 32, 1, 1, 'V', 'V'),
- 'LENB' : (211, 1, 1, 'V', 'V'),
- 'LINEST' : ( 49, 1, 4, 'A', 'RRVV'),
- 'LN' : ( 22, 1, 1, 'V', 'V'),
- 'LOG' : (109, 1, 2, 'V', 'VV'),
- 'LOG10' : ( 23, 1, 1, 'V', 'V'),
- 'LOGEST' : ( 51, 1, 4, 'A', 'RRVV'),
- 'LOGINV' : (291, 3, 3, 'V', 'VVV'),
- 'LOGNORMDIST' : (290, 3, 3, 'V', 'VVV'),
- 'LOOKUP' : ( 28, 2, 3, 'V', 'VRR'),
- 'LOWER' : (112, 1, 1, 'V', 'V'),
- 'MATCH' : ( 64, 2, 3, 'V', 'VRR'),
- 'MAX' : ( 7, 1, 30, 'V', 'D+'),
- 'MAXA' : (362, 1, 30, 'V', 'D+'),
- 'MDETERM' : (163, 1, 1, 'V', 'A'),
- 'MDURATION' : ( -1, 5, 6, 'V', 'VVVVVV'),
- 'MEDIAN' : (227, 1, 30, 'V', 'D+'),
- 'MID' : ( 31, 3, 3, 'V', 'VVV'),
- 'MIDB' : (210, 3, 3, 'V', 'VVV'),
- 'MIN' : ( 6, 1, 30, 'V', 'D+'),
- 'MINA' : (363, 1, 30, 'V', 'D+'),
- 'MINUTE' : ( 72, 1, 1, 'V', 'V'),
- 'MINVERSE' : (164, 1, 1, 'A', 'A'),
- 'MIRR' : ( 61, 3, 3, 'V', 'RVV'),
- 'MMULT' : (165, 2, 2, 'A', 'AA'),
- 'MOD' : ( 39, 2, 2, 'V', 'VV'),
- 'MODE' : (330, 1, 30, 'V', 'A+'), ################ weird #################
- 'MONTH' : ( 68, 1, 1, 'V', 'V'),
- 'MROUND' : ( -1, 2, 2, 'V', 'VV'),
- 'MULTINOMIAL' : ( -1, 1, 29, 'V', 'V+'),
- 'N' : (131, 1, 1, 'V', 'R'),
- 'NA' : ( 10, 0, 0, 'V', '-'),
- 'NEGBINOMDIST': (292, 3, 3, 'V', 'VVV'),
- 'NETWORKDAYS' : ( -1, 2, 3, 'V', 'VVR'),
- 'NOMINAL' : ( -1, 2, 2, 'V', 'VV'),
- 'NORMDIST' : (293, 4, 4, 'V', 'VVVV'),
- 'NORMINV' : (295, 3, 3, 'V', 'VVV'),
- 'NORMSDIST' : (294, 1, 1, 'V', 'V'),
- 'NORMSINV' : (296, 1, 1, 'V', 'V'),
- 'NOT' : ( 38, 1, 1, 'V', 'V'),
- 'NOW' : ( 74, 0, 0, 'V', '-'),
- 'NPER' : ( 58, 3, 5, 'V', 'VVVVV'),
- 'NPV' : ( 11, 2, 30, 'V', 'VD+'),
- 'OCT2BIN' : ( -1, 1, 2, 'V', 'VV'),
- 'OCT2DEC' : ( -1, 1, 1, 'V', 'V'),
- 'OCT2HEX' : ( -1, 1, 2, 'V', 'VV'),
- 'ODD' : (298, 1, 1, 'V', 'V'),
- 'ODDFPRICE' : ( -1, 9, 9, 'V', 'VVVVVVVVV'),
- 'ODDFYIELD' : ( -1, 9, 9, 'V', 'VVVVVVVVV'),
- 'ODDLPRICE' : ( -1, 8, 8, 'V', 'VVVVVVVV'),
- 'ODDLYIELD' : ( -1, 8, 8, 'V', 'VVVVVVVV'),
- 'OFFSET' : ( 78, 3, 5, 'R', 'RVVVV'),
- 'OR' : ( 37, 1, 30, 'V', 'D+'),
- 'PEARSON' : (312, 2, 2, 'V', 'AA'),
- 'PERCENTILE' : (328, 2, 2, 'V', 'RV'),
- 'PERCENTRANK' : (329, 2, 3, 'V', 'RVV'),
- 'PERMUT' : (299, 2, 2, 'V', 'VV'),
- 'PHONETIC' : (360, 1, 1, 'V', 'R'),
- 'PI' : ( 19, 0, 0, 'V', '-'),
- 'PMT' : ( 59, 3, 5, 'V', 'VVVVV'),
- 'POISSON' : (300, 3, 3, 'V', 'VVV'),
- 'POWER' : (337, 2, 2, 'V', 'VV'),
- 'PPMT' : (168, 4, 6, 'V', 'VVVVVV'),
- 'PRICE' : ( -1, 6, 7, 'V', 'VVVVVVV'),
- 'PRICEDISC' : ( -1, 4, 5, 'V', 'VVVVV'),
- 'PRICEMAT' : ( -1, 5, 6, 'V', 'VVVVVV'),
- 'PROB' : (317, 3, 4, 'V', 'AAVV'),
- 'PRODUCT' : (183, 1, 30, 'V', 'D+'),
- 'PROPER' : (114, 1, 1, 'V', 'V'),
- 'PV' : ( 56, 3, 5, 'V', 'VVVVV'),
- 'QUARTILE' : (327, 2, 2, 'V', 'RV'),
- 'QUOTIENT' : ( -1, 2, 2, 'V', 'VV'),
- 'RADIANS' : (342, 1, 1, 'V', 'V'),
- 'RAND' : ( 63, 0, 0, 'V', '-'),
- 'RANDBETWEEN' : ( -1, 2, 2, 'V', 'VV'),
- 'RANK' : (216, 2, 3, 'V', 'VRV'),
- 'RATE' : ( 60, 3, 6, 'V', 'VVVVVV'),
- 'RECEIVED' : ( -1, 4, 5, 'V', 'VVVVV'),
- 'REPLACE' : (119, 4, 4, 'V', 'VVVV'),
- 'REPLACEB' : (207, 4, 4, 'V', 'VVVV'),
- 'REPT' : ( 30, 2, 2, 'V', 'VV'),
- 'RIGHT' : (116, 1, 2, 'V', 'VV'),
- 'RIGHTB' : (209, 1, 2, 'V', 'VV'),
- 'ROMAN' : (354, 1, 2, 'V', 'VV'),
- 'ROUND' : ( 27, 2, 2, 'V', 'VV'),
- 'ROUNDDOWN' : (213, 2, 2, 'V', 'VV'),
- 'ROUNDUP' : (212, 2, 2, 'V', 'VV'),
- 'ROW' : ( 8, 0, 1, 'V', 'R'),
- 'ROWS' : ( 76, 1, 1, 'V', 'R'),
- 'RSQ' : (313, 2, 2, 'V', 'AA'),
- 'RTD' : (379, 3, 30, 'A', 'VVV+'),
- 'SEARCH' : ( 82, 2, 3, 'V', 'VVV'),
- 'SEARCHB' : (206, 2, 3, 'V', 'VVV'),
- 'SECOND' : ( 73, 1, 1, 'V', 'V'),
- 'SERIESSUM' : ( -1, 4, 4, 'V', 'VVVA'),
- 'SIGN' : ( 26, 1, 1, 'V', 'V'),
- 'SIN' : ( 15, 1, 1, 'V', 'V'),
- 'SINH' : (229, 1, 1, 'V', 'V'),
- 'SKEW' : (323, 1, 30, 'V', 'D+'),
- 'SLN' : (142, 3, 3, 'V', 'VVV'),
- 'SLOPE' : (315, 2, 2, 'V', 'AA'),
- 'SMALL' : (326, 2, 2, 'V', 'RV'),
- 'SQRT' : ( 20, 1, 1, 'V', 'V'),
- 'SQRTPI' : ( -1, 1, 1, 'V', 'V'),
- 'STANDARDIZE' : (297, 3, 3, 'V', 'VVV'),
- 'STDEV' : ( 12, 1, 30, 'V', 'D+'),
- 'STDEVA' : (366, 1, 30, 'V', 'D+'),
- 'STDEVP' : (193, 1, 30, 'V', 'D+'),
- 'STDEVPA' : (364, 1, 30, 'V', 'D+'),
- 'STEYX' : (314, 2, 2, 'V', 'AA'),
- 'SUBSTITUTE' : (120, 3, 4, 'V', 'VVVV'),
- 'SUBTOTAL' : (344, 2, 30, 'V', 'VR+'),
- 'SUM' : ( 4, 1, 30, 'V', 'D+'),
- 'SUMIF' : (345, 2, 3, 'V', 'RVR'),
- 'SUMPRODUCT' : (228, 1, 30, 'V', 'A+'),
- 'SUMSQ' : (321, 1, 30, 'V', 'D+'),
- 'SUMX2MY2' : (304, 2, 2, 'V', 'AA'),
- 'SUMX2PY2' : (305, 2, 2, 'V', 'AA'),
- 'SUMXMY2' : (303, 2, 2, 'V', 'AA'),
- 'SYD' : (143, 4, 4, 'V', 'VVVV'),
- 'T' : (130, 1, 1, 'V', 'R'),
- 'TAN' : ( 17, 1, 1, 'V', 'V'),
- 'TANH' : (231, 1, 1, 'V', 'V'),
- 'TBILLEQ' : ( -1, 3, 3, 'V', 'VVV'),
- 'TBILLPRICE' : ( -1, 3, 3, 'V', 'VVV'),
- 'TBILLYIELD' : ( -1, 3, 3, 'V', 'VVV'),
- 'TDIST' : (301, 3, 3, 'V', 'VVV'),
- 'TEXT' : ( 48, 2, 2, 'V', 'VV'),
- 'TIME' : ( 66, 3, 3, 'V', 'VVV'),
- 'TIMEVALUE' : (141, 1, 1, 'V', 'V'),
- 'TINV' : (332, 2, 2, 'V', 'VV'),
- 'TODAY' : (221, 0, 0, 'V', '-'),
- 'TRANSPOSE' : ( 83, 1, 1, 'A', 'A'),
- 'TREND' : ( 50, 1, 4, 'A', 'RRRV'),
- 'TRIM' : (118, 1, 1, 'V', 'V'),
- 'TRIMMEAN' : (331, 2, 2, 'V', 'RV'),
- 'TRUE' : ( 34, 0, 0, 'V', '-'),
- 'TRUNC' : (197, 1, 2, 'V', 'VV'),
- 'TTEST' : (316, 4, 4, 'V', 'AAVV'),
- 'TYPE' : ( 86, 1, 1, 'V', 'V'),
- 'UPPER' : (113, 1, 1, 'V', 'V'),
- 'USDOLLAR' : (204, 1, 2, 'V', 'VV'),
- 'VALUE' : ( 33, 1, 1, 'V', 'V'),
- 'VAR' : ( 46, 1, 30, 'V', 'D+'),
- 'VARA' : (367, 1, 30, 'V', 'D+'),
- 'VARP' : (194, 1, 30, 'V', 'D+'),
- 'VARPA' : (365, 1, 30, 'V', 'D+'),
- 'VDB' : (222, 5, 7, 'V', 'VVVVVVV'),
- 'VLOOKUP' : (102, 3, 4, 'V', 'VRRV'),
- 'WEEKDAY' : ( 70, 1, 2, 'V', 'VV'),
- 'WEEKNUM' : ( -1, 1, 2, 'V', 'VV'),
- 'WEIBULL' : (302, 4, 4, 'V', 'VVVV'),
- 'WORKDAY' : ( -1, 2, 3, 'V', 'VVR'),
- 'XIRR' : ( -1, 2, 3, 'V', 'AAV'),
- 'XNPV' : ( -1, 3, 3, 'V', 'VAA'),
- 'YEAR' : ( 69, 1, 1, 'V', 'V'),
- 'YEARFRAC' : ( -1, 2, 3, 'V', 'VVV'),
- 'YIELD' : ( -1, 6, 7, 'V', 'VVVVVVV'),
- 'YIELDDISC' : ( -1, 4, 5, 'V', 'VVVVV'),
- 'YIELDMAT' : ( -1, 5, 6, 'V', 'VVVVVV'),
- 'ZTEST' : (324, 2, 3, 'V', 'RVV'),
- }
-
-# Formulas Parse things
-
-ptgExp = 0x01
-ptgTbl = 0x02
-ptgAdd = 0x03
-ptgSub = 0x04
-ptgMul = 0x05
-ptgDiv = 0x06
-ptgPower = 0x07
-ptgConcat = 0x08
-ptgLT = 0x09
-ptgLE = 0x0a
-ptgEQ = 0x0b
-ptgGE = 0x0c
-ptgGT = 0x0d
-ptgNE = 0x0e
-ptgIsect = 0x0f
-ptgUnion = 0x10
-ptgRange = 0x11
-ptgUplus = 0x12
-ptgUminus = 0x13
-ptgPercent = 0x14
-ptgParen = 0x15
-ptgMissArg = 0x16
-ptgStr = 0x17
-ptgExtend = 0x18
-ptgAttr = 0x19
-ptgSheet = 0x1a
-ptgEndSheet = 0x1b
-ptgErr = 0x1c
-ptgBool = 0x1d
-ptgInt = 0x1e
-ptgNum = 0x1f
-
-ptgArrayR = 0x20
-ptgFuncR = 0x21
-ptgFuncVarR = 0x22
-ptgNameR = 0x23
-ptgRefR = 0x24
-ptgAreaR = 0x25
-ptgMemAreaR = 0x26
-ptgMemErrR = 0x27
-ptgMemNoMemR = 0x28
-ptgMemFuncR = 0x29
-ptgRefErrR = 0x2a
-ptgAreaErrR = 0x2b
-ptgRefNR = 0x2c
-ptgAreaNR = 0x2d
-ptgMemAreaNR = 0x2e
-ptgMemNoMemNR = 0x2f
-ptgNameXR = 0x39
-ptgRef3dR = 0x3a
-ptgArea3dR = 0x3b
-ptgRefErr3dR = 0x3c
-ptgAreaErr3dR = 0x3d
-
-ptgArrayV = 0x40
-ptgFuncV = 0x41
-ptgFuncVarV = 0x42
-ptgNameV = 0x43
-ptgRefV = 0x44
-ptgAreaV = 0x45
-ptgMemAreaV = 0x46
-ptgMemErrV = 0x47
-ptgMemNoMemV = 0x48
-ptgMemFuncV = 0x49
-ptgRefErrV = 0x4a
-ptgAreaErrV = 0x4b
-ptgRefNV = 0x4c
-ptgAreaNV = 0x4d
-ptgMemAreaNV = 0x4e
-ptgMemNoMemNV = 0x4f
-ptgFuncCEV = 0x58
-ptgNameXV = 0x59
-ptgRef3dV = 0x5a
-ptgArea3dV = 0x5b
-ptgRefErr3dV = 0x5c
-ptgAreaErr3dV = 0x5d
-
-ptgArrayA = 0x60
-ptgFuncA = 0x61
-ptgFuncVarA = 0x62
-ptgNameA = 0x63
-ptgRefA = 0x64
-ptgAreaA = 0x65
-ptgMemAreaA = 0x66
-ptgMemErrA = 0x67
-ptgMemNoMemA = 0x68
-ptgMemFuncA = 0x69
-ptgRefErrA = 0x6a
-ptgAreaErrA = 0x6b
-ptgRefNA = 0x6c
-ptgAreaNA = 0x6d
-ptgMemAreaNA = 0x6e
-ptgMemNoMemNA = 0x6f
-ptgFuncCEA = 0x78
-ptgNameXA = 0x79
-ptgRef3dA = 0x7a
-ptgArea3dA = 0x7b
-ptgRefErr3dA = 0x7c
-ptgAreaErr3dA = 0x7d
-
-
-PtgNames = {
- ptgExp : "ptgExp",
- ptgTbl : "ptgTbl",
- ptgAdd : "ptgAdd",
- ptgSub : "ptgSub",
- ptgMul : "ptgMul",
- ptgDiv : "ptgDiv",
- ptgPower : "ptgPower",
- ptgConcat : "ptgConcat",
- ptgLT : "ptgLT",
- ptgLE : "ptgLE",
- ptgEQ : "ptgEQ",
- ptgGE : "ptgGE",
- ptgGT : "ptgGT",
- ptgNE : "ptgNE",
- ptgIsect : "ptgIsect",
- ptgUnion : "ptgUnion",
- ptgRange : "ptgRange",
- ptgUplus : "ptgUplus",
- ptgUminus : "ptgUminus",
- ptgPercent : "ptgPercent",
- ptgParen : "ptgParen",
- ptgMissArg : "ptgMissArg",
- ptgStr : "ptgStr",
- ptgExtend : "ptgExtend",
- ptgAttr : "ptgAttr",
- ptgSheet : "ptgSheet",
- ptgEndSheet : "ptgEndSheet",
- ptgErr : "ptgErr",
- ptgBool : "ptgBool",
- ptgInt : "ptgInt",
- ptgNum : "ptgNum",
- ptgArrayR : "ptgArrayR",
- ptgFuncR : "ptgFuncR",
- ptgFuncVarR : "ptgFuncVarR",
- ptgNameR : "ptgNameR",
- ptgRefR : "ptgRefR",
- ptgAreaR : "ptgAreaR",
- ptgMemAreaR : "ptgMemAreaR",
- ptgMemErrR : "ptgMemErrR",
- ptgMemNoMemR : "ptgMemNoMemR",
- ptgMemFuncR : "ptgMemFuncR",
- ptgRefErrR : "ptgRefErrR",
- ptgAreaErrR : "ptgAreaErrR",
- ptgRefNR : "ptgRefNR",
- ptgAreaNR : "ptgAreaNR",
- ptgMemAreaNR : "ptgMemAreaNR",
- ptgMemNoMemNR : "ptgMemNoMemNR",
- ptgNameXR : "ptgNameXR",
- ptgRef3dR : "ptgRef3dR",
- ptgArea3dR : "ptgArea3dR",
- ptgRefErr3dR : "ptgRefErr3dR",
- ptgAreaErr3dR : "ptgAreaErr3dR",
- ptgArrayV : "ptgArrayV",
- ptgFuncV : "ptgFuncV",
- ptgFuncVarV : "ptgFuncVarV",
- ptgNameV : "ptgNameV",
- ptgRefV : "ptgRefV",
- ptgAreaV : "ptgAreaV",
- ptgMemAreaV : "ptgMemAreaV",
- ptgMemErrV : "ptgMemErrV",
- ptgMemNoMemV : "ptgMemNoMemV",
- ptgMemFuncV : "ptgMemFuncV",
- ptgRefErrV : "ptgRefErrV",
- ptgAreaErrV : "ptgAreaErrV",
- ptgRefNV : "ptgRefNV",
- ptgAreaNV : "ptgAreaNV",
- ptgMemAreaNV : "ptgMemAreaNV",
- ptgMemNoMemNV : "ptgMemNoMemNV",
- ptgFuncCEV : "ptgFuncCEV",
- ptgNameXV : "ptgNameXV",
- ptgRef3dV : "ptgRef3dV",
- ptgArea3dV : "ptgArea3dV",
- ptgRefErr3dV : "ptgRefErr3dV",
- ptgAreaErr3dV : "ptgAreaErr3dV",
- ptgArrayA : "ptgArrayA",
- ptgFuncA : "ptgFuncA",
- ptgFuncVarA : "ptgFuncVarA",
- ptgNameA : "ptgNameA",
- ptgRefA : "ptgRefA",
- ptgAreaA : "ptgAreaA",
- ptgMemAreaA : "ptgMemAreaA",
- ptgMemErrA : "ptgMemErrA",
- ptgMemNoMemA : "ptgMemNoMemA",
- ptgMemFuncA : "ptgMemFuncA",
- ptgRefErrA : "ptgRefErrA",
- ptgAreaErrA : "ptgAreaErrA",
- ptgRefNA : "ptgRefNA",
- ptgAreaNA : "ptgAreaNA",
- ptgMemAreaNA : "ptgMemAreaNA",
- ptgMemNoMemNA : "ptgMemNoMemNA",
- ptgFuncCEA : "ptgFuncCEA",
- ptgNameXA : "ptgNameXA",
- ptgRef3dA : "ptgRef3dA",
- ptgArea3dA : "ptgArea3dA",
- ptgRefErr3dA : "ptgRefErr3dA",
- ptgAreaErr3dA : "ptgAreaErr3dA"
-}
-
-
-error_msg_by_code = {
- 0x00: u"#NULL!", # intersection of two cell ranges is empty
- 0x07: u"#DIV/0!", # division by zero
- 0x0F: u"#VALUE!", # wrong type of operand
- 0x17: u"#REF!", # illegal or deleted cell reference
- 0x1D: u"#NAME?", # wrong function or range name
- 0x24: u"#NUM!", # value range overflow
- 0x2A: u"#N/A!" # argument or function not available
-}
diff --git a/tablib/packages/xlwt/Formatting.py b/tablib/packages/xlwt/Formatting.py deleted file mode 100644 index 4474b3f..0000000 --- a/tablib/packages/xlwt/Formatting.py +++ /dev/null @@ -1,261 +0,0 @@ -#!/usr/bin/env python
-'''
-The XF record is able to store explicit cell formatting attributes or the
-attributes of a cell style. Explicit formatting includes the reference to
-a cell style XF record. This allows to extend a defined cell style with
-some explicit attributes. The formatting attributes are divided into
-6 groups:
-
-Group Attributes
--------------------------------------
-Number format Number format index (index to FORMAT record)
-Font Font index (index to FONT record)
-Alignment Horizontal and vertical alignment, text wrap, indentation,
- orientation/rotation, text direction
-Border Border line styles and colours
-Background Background area style and colours
-Protection Cell locked, formula hidden
-
-For each group a flag in the cell XF record specifies whether to use the
-attributes contained in that XF record or in the referenced style
-XF record. In style XF records, these flags specify whether the attributes
-will overwrite explicit cell formatting when the style is applied to
-a cell. Changing a cell style (without applying this style to a cell) will
-change all cells which already use that style and do not contain explicit
-cell attributes for the changed style attributes. If a cell XF record does
-not contain explicit attributes in a group (if the attribute group flag
-is not set), it repeats the attributes of its style XF record.
-
-'''
-
-import BIFFRecords
-
-class Font(object):
-
- ESCAPEMENT_NONE = 0x00
- ESCAPEMENT_SUPERSCRIPT = 0x01
- ESCAPEMENT_SUBSCRIPT = 0x02
-
- UNDERLINE_NONE = 0x00
- UNDERLINE_SINGLE = 0x01
- UNDERLINE_SINGLE_ACC = 0x21
- UNDERLINE_DOUBLE = 0x02
- UNDERLINE_DOUBLE_ACC = 0x22
-
- FAMILY_NONE = 0x00
- FAMILY_ROMAN = 0x01
- FAMILY_SWISS = 0x02
- FAMILY_MODERN = 0x03
- FAMILY_SCRIPT = 0x04
- FAMILY_DECORATIVE = 0x05
-
- CHARSET_ANSI_LATIN = 0x00
- CHARSET_SYS_DEFAULT = 0x01
- CHARSET_SYMBOL = 0x02
- CHARSET_APPLE_ROMAN = 0x4D
- CHARSET_ANSI_JAP_SHIFT_JIS = 0x80
- CHARSET_ANSI_KOR_HANGUL = 0x81
- CHARSET_ANSI_KOR_JOHAB = 0x82
- CHARSET_ANSI_CHINESE_GBK = 0x86
- CHARSET_ANSI_CHINESE_BIG5 = 0x88
- CHARSET_ANSI_GREEK = 0xA1
- CHARSET_ANSI_TURKISH = 0xA2
- CHARSET_ANSI_VIETNAMESE = 0xA3
- CHARSET_ANSI_HEBREW = 0xB1
- CHARSET_ANSI_ARABIC = 0xB2
- CHARSET_ANSI_BALTIC = 0xBA
- CHARSET_ANSI_CYRILLIC = 0xCC
- CHARSET_ANSI_THAI = 0xDE
- CHARSET_ANSI_LATIN_II = 0xEE
- CHARSET_OEM_LATIN_I = 0xFF
-
- def __init__(self):
- # twip = 1/20 of a point = 1/1440 of a inch
- # usually resolution == 96 pixels per 1 inch
- # (rarely 120 pixels per 1 inch or another one)
-
- self.height = 0x00C8 # 200: this is font with height 10 points
- self.italic = False
- self.struck_out = False
- self.outline = False
- self.shadow = False
- self.colour_index = 0x7FFF
- self.bold = False
- self._weight = 0x0190 # 0x02BC gives bold font
- self.escapement = self.ESCAPEMENT_NONE
- self.underline = self.UNDERLINE_NONE
- self.family = self.FAMILY_NONE
- self.charset = self.CHARSET_SYS_DEFAULT
- self.name = 'Arial'
-
- def get_biff_record(self):
- height = self.height
-
- options = 0x00
- if self.bold:
- options |= 0x01
- self._weight = 0x02BC
- if self.italic:
- options |= 0x02
- if self.underline != self.UNDERLINE_NONE:
- options |= 0x04
- if self.struck_out:
- options |= 0x08
- if self.outline:
- options |= 0x010
- if self.shadow:
- options |= 0x020
-
- colour_index = self.colour_index
- weight = self._weight
- escapement = self.escapement
- underline = self.underline
- family = self.family
- charset = self.charset
- name = self.name
-
- return BIFFRecords.FontRecord(height, options, colour_index, weight, escapement,
- underline, family, charset,
- name)
-
- def _search_key(self):
- return (
- self.height,
- self.italic,
- self.struck_out,
- self.outline,
- self.shadow,
- self.colour_index,
- self.bold,
- self._weight,
- self.escapement,
- self.underline,
- self.family,
- self.charset,
- self.name,
- )
-
-class Alignment(object):
- HORZ_GENERAL = 0x00
- HORZ_LEFT = 0x01
- HORZ_CENTER = 0x02
- HORZ_RIGHT = 0x03
- HORZ_FILLED = 0x04
- HORZ_JUSTIFIED = 0x05 # BIFF4-BIFF8X
- HORZ_CENTER_ACROSS_SEL = 0x06 # Centred across selection (BIFF4-BIFF8X)
- HORZ_DISTRIBUTED = 0x07 # Distributed (BIFF8X)
-
- VERT_TOP = 0x00
- VERT_CENTER = 0x01
- VERT_BOTTOM = 0x02
- VERT_JUSTIFIED = 0x03 # Justified (BIFF5-BIFF8X)
- VERT_DISTRIBUTED = 0x04 # Distributed (BIFF8X)
-
- DIRECTION_GENERAL = 0x00 # BIFF8X
- DIRECTION_LR = 0x01
- DIRECTION_RL = 0x02
-
- ORIENTATION_NOT_ROTATED = 0x00
- ORIENTATION_STACKED = 0x01
- ORIENTATION_90_CC = 0x02
- ORIENTATION_90_CW = 0x03
-
- ROTATION_0_ANGLE = 0x00
- ROTATION_STACKED = 0xFF
-
- WRAP_AT_RIGHT = 0x01
- NOT_WRAP_AT_RIGHT = 0x00
-
- SHRINK_TO_FIT = 0x01
- NOT_SHRINK_TO_FIT = 0x00
-
- def __init__(self):
- self.horz = self.HORZ_GENERAL
- self.vert = self.VERT_BOTTOM
- self.dire = self.DIRECTION_GENERAL
- self.orie = self.ORIENTATION_NOT_ROTATED
- self.rota = self.ROTATION_0_ANGLE
- self.wrap = self.NOT_WRAP_AT_RIGHT
- self.shri = self.NOT_SHRINK_TO_FIT
- self.inde = 0
- self.merg = 0
-
- def _search_key(self):
- return (
- self.horz, self.vert, self.dire, self.orie, self.rota,
- self.wrap, self.shri, self.inde, self.merg,
- )
-
-class Borders(object):
- NO_LINE = 0x00
- THIN = 0x01
- MEDIUM = 0x02
- DASHED = 0x03
- DOTTED = 0x04
- THICK = 0x05
- DOUBLE = 0x06
- HAIR = 0x07
- #The following for BIFF8
- MEDIUM_DASHED = 0x08
- THIN_DASH_DOTTED = 0x09
- MEDIUM_DASH_DOTTED = 0x0A
- THIN_DASH_DOT_DOTTED = 0x0B
- MEDIUM_DASH_DOT_DOTTED = 0x0C
- SLANTED_MEDIUM_DASH_DOTTED = 0x0D
-
- NEED_DIAG1 = 0x01
- NEED_DIAG2 = 0x01
- NO_NEED_DIAG1 = 0x00
- NO_NEED_DIAG2 = 0x00
-
- def __init__(self):
- self.left = self.NO_LINE
- self.right = self.NO_LINE
- self.top = self.NO_LINE
- self.bottom = self.NO_LINE
- self.diag = self.NO_LINE
-
- self.left_colour = 0x40
- self.right_colour = 0x40
- self.top_colour = 0x40
- self.bottom_colour = 0x40
- self.diag_colour = 0x40
-
- self.need_diag1 = self.NO_NEED_DIAG1
- self.need_diag2 = self.NO_NEED_DIAG2
-
- def _search_key(self):
- return (
- self.left, self.right, self.top, self.bottom, self.diag,
- self.left_colour, self.right_colour, self.top_colour,
- self.bottom_colour, self.diag_colour,
- self.need_diag1, self.need_diag2,
- )
-
-class Pattern(object):
- # patterns 0x00 - 0x12
- NO_PATTERN = 0x00
- SOLID_PATTERN = 0x01
-
- def __init__(self):
- self.pattern = self.NO_PATTERN
- self.pattern_fore_colour = 0x40
- self.pattern_back_colour = 0x41
-
- def _search_key(self):
- return (
- self.pattern,
- self.pattern_fore_colour,
- self.pattern_back_colour,
- )
-
-class Protection(object):
- def __init__(self):
- self.cell_locked = 1
- self.formula_hidden = 0
-
- def _search_key(self):
- return (
- self.cell_locked,
- self.formula_hidden,
- )
diff --git a/tablib/packages/xlwt/Row.py b/tablib/packages/xlwt/Row.py deleted file mode 100644 index bb40f43..0000000 --- a/tablib/packages/xlwt/Row.py +++ /dev/null @@ -1,253 +0,0 @@ -# -*- coding: windows-1252 -*-
-
-import BIFFRecords
-import Style
-from Cell import StrCell, BlankCell, NumberCell, FormulaCell, MulBlankCell, BooleanCell, ErrorCell, \
- _get_cells_biff_data_mul
-import ExcelFormula
-import datetime as dt
-try:
- from decimal import Decimal
-except ImportError:
- # Python 2.3: decimal not supported; create dummy Decimal class
- class Decimal(object):
- pass
-
-
-class Row(object):
- __slots__ = [# private variables
- "__idx",
- "__parent",
- "__parent_wb",
- "__cells",
- "__min_col_idx",
- "__max_col_idx",
- "__xf_index",
- "__has_default_xf_index",
- "__height_in_pixels",
- # public variables
- "height",
- "has_default_height",
- "height_mismatch",
- "level",
- "collapse",
- "hidden",
- "space_above",
- "space_below"]
-
- def __init__(self, rowx, parent_sheet):
- if not (isinstance(rowx, int) and 0 <= rowx <= 65535):
- raise ValueError("row index (%r) not an int in range(65536)" % rowx)
- self.__idx = rowx
- self.__parent = parent_sheet
- self.__parent_wb = parent_sheet.get_parent()
- self.__cells = {}
- self.__min_col_idx = 0
- self.__max_col_idx = 0
- self.__xf_index = 0x0F
- self.__has_default_xf_index = 0
- self.__height_in_pixels = 0x11
-
- self.height = 0x00FF
- self.has_default_height = 0x00
- self.height_mismatch = 0
- self.level = 0
- self.collapse = 0
- self.hidden = 0
- self.space_above = 0
- self.space_below = 0
-
-
- def __adjust_height(self, style):
- twips = style.font.height
- points = float(twips)/20.0
- # Cell height in pixels can be calcuted by following approx. formula:
- # cell height in pixels = font height in points * 83/50 + 2/5
- # It works when screen resolution is 96 dpi
- pix = int(round(points*83.0/50.0 + 2.0/5.0))
- if pix > self.__height_in_pixels:
- self.__height_in_pixels = pix
-
-
- def __adjust_bound_col_idx(self, *args):
- for arg in args:
- iarg = int(arg)
- if not ((0 <= iarg <= 255) and arg == iarg):
- raise ValueError("column index (%r) not an int in range(256)" % arg)
- sheet = self.__parent
- if iarg < self.__min_col_idx:
- self.__min_col_idx = iarg
- if iarg > self.__max_col_idx:
- self.__max_col_idx = iarg
- if iarg < sheet.first_used_col:
- sheet.first_used_col = iarg
- if iarg > sheet.last_used_col:
- sheet.last_used_col = iarg
-
- def __excel_date_dt(self, date):
- if isinstance(date, dt.date) and (not isinstance(date, dt.datetime)):
- epoch = dt.date(1899, 12, 31)
- elif isinstance(date, dt.time):
- date = dt.datetime.combine(dt.datetime(1900, 1, 1), date)
- epoch = dt.datetime(1900, 1, 1, 0, 0, 0)
- else:
- epoch = dt.datetime(1899, 12, 31, 0, 0, 0)
- delta = date - epoch
- xldate = delta.days + float(delta.seconds) / (24*60*60)
- # Add a day for Excel's missing leap day in 1900
- if xldate > 59:
- xldate += 1
- return xldate
-
- def get_height_in_pixels(self):
- return self.__height_in_pixels
-
-
- def set_style(self, style):
- self.__adjust_height(style)
- self.__xf_index = self.__parent_wb.add_style(style)
- self.__has_default_xf_index = 1
-
-
- def get_xf_index(self):
- return self.__xf_index
-
-
- def get_cells_count(self):
- return len(self.__cells)
-
-
- def get_min_col(self):
- return self.__min_col_idx
-
-
- def get_max_col(self):
- return self.__max_col_idx
-
-
- def get_row_biff_data(self):
- height_options = (self.height & 0x07FFF)
- height_options |= (self.has_default_height & 0x01) << 15
-
- options = (self.level & 0x07) << 0
- options |= (self.collapse & 0x01) << 4
- options |= (self.hidden & 0x01) << 5
- options |= (self.height_mismatch & 0x01) << 6
- options |= (self.__has_default_xf_index & 0x01) << 7
- options |= (0x01 & 0x01) << 8
- options |= (self.__xf_index & 0x0FFF) << 16
- options |= (self.space_above & 1) << 28
- options |= (self.space_below & 1) << 29
-
- return BIFFRecords.RowRecord(self.__idx, self.__min_col_idx,
- self.__max_col_idx, height_options, options).get()
-
- def insert_cell(self, col_index, cell_obj):
- if col_index in self.__cells:
- if not self.__parent._cell_overwrite_ok:
- msg = "Attempt to overwrite cell: sheetname=%r rowx=%d colx=%d" \
- % (self.__parent.name, self.__idx, col_index)
- raise Exception(msg)
- prev_cell_obj = self.__cells[col_index]
- sst_idx = getattr(prev_cell_obj, 'sst_idx', None)
- if sst_idx is not None:
- self.__parent_wb.del_str(sst_idx)
- self.__cells[col_index] = cell_obj
-
- def insert_mulcells(self, colx1, colx2, cell_obj):
- self.insert_cell(colx1, cell_obj)
- for col_index in xrange(colx1+1, colx2+1):
- self.insert_cell(col_index, None)
-
- def get_cells_biff_data(self):
- cell_items = [item for item in self.__cells.iteritems() if item[1] is not None]
- cell_items.sort() # in column order
- return _get_cells_biff_data_mul(self.__idx, cell_items)
- # previously:
- # return ''.join([cell.get_biff_data() for colx, cell in cell_items])
-
- def get_index(self):
- return self.__idx
-
- def set_cell_text(self, colx, value, style=Style.default_style):
- self.__adjust_height(style)
- self.__adjust_bound_col_idx(colx)
- xf_index = self.__parent_wb.add_style(style)
- self.insert_cell(colx, StrCell(self.__idx, colx, xf_index, self.__parent_wb.add_str(value)))
-
- def set_cell_blank(self, colx, style=Style.default_style):
- self.__adjust_height(style)
- self.__adjust_bound_col_idx(colx)
- xf_index = self.__parent_wb.add_style(style)
- self.insert_cell(colx, BlankCell(self.__idx, colx, xf_index))
-
- def set_cell_mulblanks(self, first_colx, last_colx, style=Style.default_style):
- assert 0 <= first_colx <= last_colx <= 255
- self.__adjust_height(style)
- self.__adjust_bound_col_idx(first_colx, last_colx)
- xf_index = self.__parent_wb.add_style(style)
- # ncols = last_colx - first_colx + 1
- self.insert_mulcells(first_colx, last_colx, MulBlankCell(self.__idx, first_colx, last_colx, xf_index))
-
- def set_cell_number(self, colx, number, style=Style.default_style):
- self.__adjust_height(style)
- self.__adjust_bound_col_idx(colx)
- xf_index = self.__parent_wb.add_style(style)
- self.insert_cell(colx, NumberCell(self.__idx, colx, xf_index, number))
-
- def set_cell_date(self, colx, datetime_obj, style=Style.default_style):
- self.__adjust_height(style)
- self.__adjust_bound_col_idx(colx)
- xf_index = self.__parent_wb.add_style(style)
- self.insert_cell(colx,
- NumberCell(self.__idx, colx, xf_index, self.__excel_date_dt(datetime_obj)))
-
- def set_cell_formula(self, colx, formula, style=Style.default_style, calc_flags=0):
- self.__adjust_height(style)
- self.__adjust_bound_col_idx(colx)
- xf_index = self.__parent_wb.add_style(style)
- self.__parent_wb.add_sheet_reference(formula)
- self.insert_cell(colx, FormulaCell(self.__idx, colx, xf_index, formula, calc_flags=0))
-
- def set_cell_boolean(self, colx, value, style=Style.default_style):
- self.__adjust_height(style)
- self.__adjust_bound_col_idx(colx)
- xf_index = self.__parent_wb.add_style(style)
- self.insert_cell(colx, BooleanCell(self.__idx, colx, xf_index, bool(value)))
-
- def set_cell_error(self, colx, error_string_or_code, style=Style.default_style):
- self.__adjust_height(style)
- self.__adjust_bound_col_idx(colx)
- xf_index = self.__parent_wb.add_style(style)
- self.insert_cell(colx, ErrorCell(self.__idx, colx, xf_index, error_string_or_code))
-
- def write(self, col, label, style=Style.default_style):
- self.__adjust_height(style)
- self.__adjust_bound_col_idx(col)
- style_index = self.__parent_wb.add_style(style)
- if isinstance(label, basestring):
- if len(label) > 0:
- self.insert_cell(col,
- StrCell(self.__idx, col, style_index, self.__parent_wb.add_str(label))
- )
- else:
- self.insert_cell(col, BlankCell(self.__idx, col, style_index))
- elif isinstance(label, bool): # bool is subclass of int; test bool first
- self.insert_cell(col, BooleanCell(self.__idx, col, style_index, label))
- elif isinstance(label, (float, int, long, Decimal)):
- self.insert_cell(col, NumberCell(self.__idx, col, style_index, label))
- elif isinstance(label, (dt.datetime, dt.date, dt.time)):
- date_number = self.__excel_date_dt(label)
- self.insert_cell(col, NumberCell(self.__idx, col, style_index, date_number))
- elif label is None:
- self.insert_cell(col, BlankCell(self.__idx, col, style_index))
- elif isinstance(label, ExcelFormula.Formula):
- self.__parent_wb.add_sheet_reference(label)
- self.insert_cell(col, FormulaCell(self.__idx, col, style_index, label))
- else:
- raise Exception("Unexpected data type %r" % type(label))
-
- write_blanks = set_cell_mulblanks
-
-
-
diff --git a/tablib/packages/xlwt/Style.py b/tablib/packages/xlwt/Style.py deleted file mode 100644 index 35748cc..0000000 --- a/tablib/packages/xlwt/Style.py +++ /dev/null @@ -1,592 +0,0 @@ -# -*- coding: windows-1252 -*-
-
-import Formatting
-from BIFFRecords import *
-
-FIRST_USER_DEFINED_NUM_FORMAT_IDX = 164
-
-class XFStyle(object):
-
- def __init__(self):
- self.num_format_str = 'General'
- self.font = Formatting.Font()
- self.alignment = Formatting.Alignment()
- self.borders = Formatting.Borders()
- self.pattern = Formatting.Pattern()
- self.protection = Formatting.Protection()
-
-default_style = XFStyle()
-
-class StyleCollection(object):
- _std_num_fmt_list = [
- 'general',
- '0',
- '0.00',
- '#,##0',
- '#,##0.00',
- '"$"#,##0_);("$"#,##',
- '"$"#,##0_);[Red]("$"#,##',
- '"$"#,##0.00_);("$"#,##',
- '"$"#,##0.00_);[Red]("$"#,##',
- '0%',
- '0.00%',
- '0.00E+00',
- '# ?/?',
- '# ??/??',
- 'M/D/YY',
- 'D-MMM-YY',
- 'D-MMM',
- 'MMM-YY',
- 'h:mm AM/PM',
- 'h:mm:ss AM/PM',
- 'h:mm',
- 'h:mm:ss',
- 'M/D/YY h:mm',
- '_(#,##0_);(#,##0)',
- '_(#,##0_);[Red](#,##0)',
- '_(#,##0.00_);(#,##0.00)',
- '_(#,##0.00_);[Red](#,##0.00)',
- '_("$"* #,##0_);_("$"* (#,##0);_("$"* "-"_);_(@_)',
- '_(* #,##0_);_(* (#,##0);_(* "-"_);_(@_)',
- '_("$"* #,##0.00_);_("$"* (#,##0.00);_("$"* "-"??_);_(@_)',
- '_(* #,##0.00_);_(* (#,##0.00);_(* "-"??_);_(@_)',
- 'mm:ss',
- '[h]:mm:ss',
- 'mm:ss.0',
- '##0.0E+0',
- '@'
- ]
-
- def __init__(self, style_compression=0):
- self.style_compression = style_compression
- self.stats = [0, 0, 0, 0, 0, 0]
- self._font_id2x = {}
- self._font_x2id = {}
- self._font_val2x = {}
-
- for x in (0, 1, 2, 3, 5): # The font with index 4 is omitted in all BIFF versions
- font = Formatting.Font()
- search_key = font._search_key()
- self._font_id2x[font] = x
- self._font_x2id[x] = font
- self._font_val2x[search_key] = x
-
- self._xf_id2x = {}
- self._xf_x2id = {}
- self._xf_val2x = {}
-
- self._num_formats = {}
- for fmtidx, fmtstr in zip(range(0, 23), StyleCollection._std_num_fmt_list[0:23]):
- self._num_formats[fmtstr] = fmtidx
- for fmtidx, fmtstr in zip(range(37, 50), StyleCollection._std_num_fmt_list[23:]):
- self._num_formats[fmtstr] = fmtidx
-
- self.default_style = XFStyle()
- self._default_xf = self._add_style(self.default_style)[0]
-
- def add(self, style):
- if style == None:
- return 0x10
- return self._add_style(style)[1]
-
- def _add_style(self, style):
- num_format_str = style.num_format_str
- if num_format_str in self._num_formats:
- num_format_idx = self._num_formats[num_format_str]
- else:
- num_format_idx = (
- FIRST_USER_DEFINED_NUM_FORMAT_IDX
- + len(self._num_formats)
- - len(StyleCollection._std_num_fmt_list)
- )
- self._num_formats[num_format_str] = num_format_idx
-
- font = style.font
- if font in self._font_id2x:
- font_idx = self._font_id2x[font]
- self.stats[0] += 1
- elif self.style_compression:
- search_key = font._search_key()
- font_idx = self._font_val2x.get(search_key)
- if font_idx is not None:
- self._font_id2x[font] = font_idx
- self.stats[1] += 1
- else:
- font_idx = len(self._font_x2id) + 1 # Why plus 1? Font 4 is missing
- self._font_id2x[font] = font_idx
- self._font_val2x[search_key] = font_idx
- self._font_x2id[font_idx] = font
- self.stats[2] += 1
- else:
- font_idx = len(self._font_id2x) + 1
- self._font_id2x[font] = font_idx
- self.stats[2] += 1
-
- gof = (style.alignment, style.borders, style.pattern, style.protection)
- xf = (font_idx, num_format_idx) + gof
- if xf in self._xf_id2x:
- xf_index = self._xf_id2x[xf]
- self.stats[3] += 1
- elif self.style_compression == 2:
- xf_key = (font_idx, num_format_idx) + tuple([obj._search_key() for obj in gof])
- xf_index = self._xf_val2x.get(xf_key)
- if xf_index is not None:
- self._xf_id2x[xf] = xf_index
- self.stats[4] += 1
- else:
- xf_index = 0x10 + len(self._xf_x2id)
- self._xf_id2x[xf] = xf_index
- self._xf_val2x[xf_key] = xf_index
- self._xf_x2id[xf_index] = xf
- self.stats[5] += 1
- else:
- xf_index = 0x10 + len(self._xf_id2x)
- self._xf_id2x[xf] = xf_index
- self.stats[5] += 1
-
- if xf_index >= 0xFFF:
- # 12 bits allowed, 0xFFF is a sentinel value
- raise ValueError("More than 4094 XFs (styles)")
-
- return xf, xf_index
-
- def get_biff_data(self):
- result = ''
- result += self._all_fonts()
- result += self._all_num_formats()
- result += self._all_cell_styles()
- result += self._all_styles()
- return result
-
- def _all_fonts(self):
- result = ''
- if self.style_compression:
- alist = self._font_x2id.items()
- else:
- alist = [(x, o) for o, x in self._font_id2x.items()]
- alist.sort()
- for font_idx, font in alist:
- result += font.get_biff_record().get()
- return result
-
- def _all_num_formats(self):
- result = ''
- alist = [
- (v, k)
- for k, v in self._num_formats.items()
- if v >= FIRST_USER_DEFINED_NUM_FORMAT_IDX
- ]
- alist.sort()
- for fmtidx, fmtstr in alist:
- result += NumberFormatRecord(fmtidx, fmtstr).get()
- return result
-
- def _all_cell_styles(self):
- result = ''
- for i in range(0, 16):
- result += XFRecord(self._default_xf, 'style').get()
- if self.style_compression == 2:
- alist = self._xf_x2id.items()
- else:
- alist = [(x, o) for o, x in self._xf_id2x.items()]
- alist.sort()
- for xf_idx, xf in alist:
- result += XFRecord(xf).get()
- return result
-
- def _all_styles(self):
- return StyleRecord().get()
-
-# easyxf and its supporting objects ###################################
-
-class EasyXFException(Exception):
- pass
-
-class EasyXFCallerError(EasyXFException):
- pass
-
-class EasyXFAuthorError(EasyXFException):
- pass
-
-class IntULim(object):
- # If astring represents a valid unsigned integer ('123', '0xabcd', etc)
- # and it is <= limit, return the int value; otherwise return None.
-
- def __init__(self, limit):
- self.limit = limit
-
- def __call__(self, astring):
- try:
- value = int(astring, 0)
- except ValueError:
- return None
- if not 0 <= value <= self.limit:
- return None
- return value
-
-bool_map = {
- # Text values for all Boolean attributes
- '1': 1, 'yes': 1, 'true': 1, 'on': 1,
- '0': 0, 'no': 0, 'false': 0, 'off': 0,
- }
-
-border_line_map = {
- # Text values for these borders attributes:
- # left, right, top, bottom and diag
- 'no_line': 0x00,
- 'thin': 0x01,
- 'medium': 0x02,
- 'dashed': 0x03,
- 'dotted': 0x04,
- 'thick': 0x05,
- 'double': 0x06,
- 'hair': 0x07,
- 'medium_dashed': 0x08,
- 'thin_dash_dotted': 0x09,
- 'medium_dash_dotted': 0x0a,
- 'thin_dash_dot_dotted': 0x0b,
- 'medium_dash_dot_dotted': 0x0c,
- 'slanted_medium_dash_dotted': 0x0d,
- }
-
-charset_map = {
- # Text values for font.charset
- 'ansi_latin': 0x00,
- 'sys_default': 0x01,
- 'symbol': 0x02,
- 'apple_roman': 0x4d,
- 'ansi_jap_shift_jis': 0x80,
- 'ansi_kor_hangul': 0x81,
- 'ansi_kor_johab': 0x82,
- 'ansi_chinese_gbk': 0x86,
- 'ansi_chinese_big5': 0x88,
- 'ansi_greek': 0xa1,
- 'ansi_turkish': 0xa2,
- 'ansi_vietnamese': 0xa3,
- 'ansi_hebrew': 0xb1,
- 'ansi_arabic': 0xb2,
- 'ansi_baltic': 0xba,
- 'ansi_cyrillic': 0xcc,
- 'ansi_thai': 0xde,
- 'ansi_latin_ii': 0xee,
- 'oem_latin_i': 0xff,
- }
-
-
-# Text values for colour indices. "grey" is a synonym of "gray".
-# The names are those given by Microsoft Excel 2003 to the colours
-# in the default palette. There is no great correspondence with
-# any W3C name-to-RGB mapping.
-_colour_map_text = """\
-aqua 0x31
-black 0x08
-blue 0x0C
-blue_gray 0x36
-bright_green 0x0B
-brown 0x3C
-coral 0x1D
-cyan_ega 0x0F
-dark_blue 0x12
-dark_blue_ega 0x12
-dark_green 0x3A
-dark_green_ega 0x11
-dark_purple 0x1C
-dark_red 0x10
-dark_red_ega 0x10
-dark_teal 0x38
-dark_yellow 0x13
-gold 0x33
-gray_ega 0x17
-gray25 0x16
-gray40 0x37
-gray50 0x17
-gray80 0x3F
-green 0x11
-ice_blue 0x1F
-indigo 0x3E
-ivory 0x1A
-lavender 0x2E
-light_blue 0x30
-light_green 0x2A
-light_orange 0x34
-light_turquoise 0x29
-light_yellow 0x2B
-lime 0x32
-magenta_ega 0x0E
-ocean_blue 0x1E
-olive_ega 0x13
-olive_green 0x3B
-orange 0x35
-pale_blue 0x2C
-periwinkle 0x18
-pink 0x0E
-plum 0x3D
-purple_ega 0x14
-red 0x0A
-rose 0x2D
-sea_green 0x39
-silver_ega 0x16
-sky_blue 0x28
-tan 0x2F
-teal 0x15
-teal_ega 0x15
-turquoise 0x0F
-violet 0x14
-white 0x09
-yellow 0x0D"""
-
-colour_map = {}
-for _line in _colour_map_text.splitlines():
- _name, _num = _line.split()
- _num = int(_num, 0)
- colour_map[_name] = _num
- if 'gray' in _name:
- colour_map[_name.replace('gray', 'grey')] = _num
-del _colour_map_text, _line, _name, _num
-
-
-pattern_map = {
- # Text values for pattern.pattern
- # xlwt/doc/pattern_examples.xls showcases all of these patterns.
- 'no_fill': 0,
- 'none': 0,
- 'solid': 1,
- 'solid_fill': 1,
- 'solid_pattern': 1,
- 'fine_dots': 2,
- 'alt_bars': 3,
- 'sparse_dots': 4,
- 'thick_horz_bands': 5,
- 'thick_vert_bands': 6,
- 'thick_backward_diag': 7,
- 'thick_forward_diag': 8,
- 'big_spots': 9,
- 'bricks': 10,
- 'thin_horz_bands': 11,
- 'thin_vert_bands': 12,
- 'thin_backward_diag': 13,
- 'thin_forward_diag': 14,
- 'squares': 15,
- 'diamonds': 16,
- }
-
-def any_str_func(s):
- return s.strip()
-
-def colour_index_func(s, maxval=0x7F):
- try:
- value = int(s, 0)
- except ValueError:
- return None
- if not (0 <= value <= maxval):
- return None
- return value
-
-colour_index_func_7 = colour_index_func
-
-def colour_index_func_15(s):
- return colour_index_func(s, maxval=0x7FFF)
-
-def rotation_func(s):
- try:
- value = int(s, 0)
- except ValueError:
- return None
- if not (-90 <= value <= 90):
- raise EasyXFCallerError("rotation %d: should be -90 to +90 degrees" % value)
- if value < 0:
- value = 90 - value # encode as 91 to 180 (clockwise)
- return value
-
-xf_dict = {
- 'align': 'alignment', # synonym
- 'alignment': {
- 'dire': {
- 'general': 0,
- 'lr': 1,
- 'rl': 2,
- },
- 'direction': 'dire',
- 'horiz': 'horz',
- 'horizontal': 'horz',
- 'horz': {
- 'general': 0,
- 'left': 1,
- 'center': 2,
- 'centre': 2, # "align: horiz centre" means xf.alignment.horz is set to 2
- 'right': 3,
- 'filled': 4,
- 'justified': 5,
- 'center_across_selection': 6,
- 'centre_across_selection': 6,
- 'distributed': 7,
- },
- 'inde': IntULim(15), # restriction: 0 <= value <= 15
- 'indent': 'inde',
- 'rota': [{'stacked': 255, 'none': 0, }, rotation_func],
- 'rotation': 'rota',
- 'shri': bool_map,
- 'shrink': 'shri',
- 'shrink_to_fit': 'shri',
- 'vert': {
- 'top': 0,
- 'center': 1,
- 'centre': 1,
- 'bottom': 2,
- 'justified': 3,
- 'distributed': 4,
- },
- 'vertical': 'vert',
- 'wrap': bool_map,
- },
- 'border': 'borders',
- 'borders': {
- 'left': [border_line_map, IntULim(0x0d)],
- 'right': [border_line_map, IntULim(0x0d)],
- 'top': [border_line_map, IntULim(0x0d)],
- 'bottom': [border_line_map, IntULim(0x0d)],
- 'diag': [border_line_map, IntULim(0x0d)],
- 'top_colour': [colour_map, colour_index_func_7],
- 'bottom_colour': [colour_map, colour_index_func_7],
- 'left_colour': [colour_map, colour_index_func_7],
- 'right_colour': [colour_map, colour_index_func_7],
- 'diag_colour': [colour_map, colour_index_func_7],
- 'top_color': 'top_colour',
- 'bottom_color': 'bottom_colour',
- 'left_color': 'left_colour',
- 'right_color': 'right_colour',
- 'diag_color': 'diag-colour',
- 'need_diag_1': bool_map,
- 'need_diag_2': bool_map,
- },
- 'font': {
- 'bold': bool_map,
- 'charset': charset_map,
- 'color': 'colour_index',
- 'color_index': 'colour_index',
- 'colour': 'colour_index',
- 'colour_index': [colour_map, colour_index_func_15],
- 'escapement': {'none': 0, 'superscript': 1, 'subscript': 2},
- 'family': {'none': 0, 'roman': 1, 'swiss': 2, 'modern': 3, 'script': 4, 'decorative': 5, },
- 'height': IntULim(0xFFFF), # practical limits are much narrower e.g. 160 to 1440 (8pt to 72pt)
- 'italic': bool_map,
- 'name': any_str_func,
- 'outline': bool_map,
- 'shadow': bool_map,
- 'struck_out': bool_map,
- 'underline': [bool_map, {'none': 0, 'single': 1, 'single_acc': 0x21, 'double': 2, 'double_acc': 0x22, }],
- },
- 'pattern': {
- 'back_color': 'pattern_back_colour',
- 'back_colour': 'pattern_back_colour',
- 'fore_color': 'pattern_fore_colour',
- 'fore_colour': 'pattern_fore_colour',
- 'pattern': [pattern_map, IntULim(16)],
- 'pattern_back_color': 'pattern_back_colour',
- 'pattern_back_colour': [colour_map, colour_index_func_7],
- 'pattern_fore_color': 'pattern_fore_colour',
- 'pattern_fore_colour': [colour_map, colour_index_func_7],
- },
- 'protection': {
- 'cell_locked' : bool_map,
- 'formula_hidden': bool_map,
- },
- }
-
-def _esplit(s, split_char, esc_char="\\"):
- escaped = False
- olist = ['']
- for c in s:
- if escaped:
- olist[-1] += c
- escaped = False
- elif c == esc_char:
- escaped = True
- elif c == split_char:
- olist.append('')
- else:
- olist[-1] += c
- return olist
-
-def _parse_strg_to_obj(strg, obj, parse_dict,
- field_sep=",", line_sep=";", intro_sep=":", esc_char="\\", debug=False):
- for line in _esplit(strg, line_sep, esc_char):
- line = line.strip()
- if not line:
- break
- split_line = _esplit(line, intro_sep, esc_char)
- if len(split_line) != 2:
- raise EasyXFCallerError('line %r should have exactly 1 "%c"' % (line, intro_sep))
- section, item_str = split_line
- section = section.strip().lower()
- for counter in range(2):
- result = parse_dict.get(section)
- if result is None:
- raise EasyXFCallerError('section %r is unknown' % section)
- if isinstance(result, dict):
- break
- if not isinstance(result, str):
- raise EasyXFAuthorError(
- 'section %r should map to dict or str object; found %r' % (section, type(result)))
- # synonym
- old_section = section
- section = result
- else:
- raise EasyXFAuthorError('Attempt to define synonym of synonym (%r: %r)' % (old_section, result))
- section_dict = result
- section_obj = getattr(obj, section, None)
- if section_obj is None:
- raise EasyXFAuthorError('instance of %s class has no attribute named %s' % (obj.__class__.__name__, section))
- for kv_str in _esplit(item_str, field_sep, esc_char):
- guff = kv_str.split()
- if not guff:
- continue
- k = guff[0].lower().replace('-', '_')
- v = ' '.join(guff[1:])
- if not v:
- raise EasyXFCallerError("no value supplied for %s.%s" % (section, k))
- for counter in xrange(2):
- result = section_dict.get(k)
- if result is None:
- raise EasyXFCallerError('%s.%s is not a known attribute' % (section, k))
- if not isinstance(result, basestring):
- break
- # synonym
- old_k = k
- k = result
- else:
- raise EasyXFAuthorError('Attempt to define synonym of synonym (%r: %r)' % (old_k, result))
- value_info = result
- if not isinstance(value_info, list):
- value_info = [value_info]
- for value_rule in value_info:
- if isinstance(value_rule, dict):
- # dict maps strings to integer field values
- vl = v.lower().replace('-', '_')
- if vl in value_rule:
- value = value_rule[vl]
- break
- elif callable(value_rule):
- value = value_rule(v)
- if value is not None:
- break
- else:
- raise EasyXFAuthorError("unknown value rule for attribute %r: %r" % (k, value_rule))
- else:
- raise EasyXFCallerError("unexpected value %r for %s.%s" % (v, section, k))
- try:
- orig = getattr(section_obj, k)
- except AttributeError:
- raise EasyXFAuthorError('%s.%s in dictionary but not in supplied object' % (section, k))
- if debug: print "+++ %s.%s = %r # %s; was %r" % (section, k, value, v, orig)
- setattr(section_obj, k, value)
-
-def easyxf(strg_to_parse="", num_format_str=None,
- field_sep=",", line_sep=";", intro_sep=":", esc_char="\\", debug=False):
- xfobj = XFStyle()
- if num_format_str is not None:
- xfobj.num_format_str = num_format_str
- if strg_to_parse:
- _parse_strg_to_obj(strg_to_parse, xfobj, xf_dict,
- field_sep=field_sep, line_sep=line_sep, intro_sep=intro_sep, esc_char=esc_char, debug=debug)
- return xfobj
diff --git a/tablib/packages/xlwt/UnicodeUtils.py b/tablib/packages/xlwt/UnicodeUtils.py deleted file mode 100644 index 4b81f57..0000000 --- a/tablib/packages/xlwt/UnicodeUtils.py +++ /dev/null @@ -1,81 +0,0 @@ -# -*- coding: windows-1252 -*-
-
-'''
-From BIFF8 on, strings are always stored using UTF-16LE text encoding. The
-character array is a sequence of 16-bit values4. Additionally it is
-possible to use a compressed format, which omits the high bytes of all
-characters, if they are all zero.
-
-The following tables describe the standard format of the entire string, but
-in many records the strings differ from this format. This will be mentioned
-separately. It is possible (but not required) to store Rich-Text formatting
-information and Asian phonetic information inside a Unicode string. This
-results in four different ways to store a string. The character array
-is not zero-terminated.
-
-The string consists of the character count (as usual an 8-bit value or
-a 16-bit value), option flags, the character array and optional formatting
-information. If the string is empty, sometimes the option flags field will
-not occur. This is mentioned at the respective place.
-
-Offset Size Contents
-0 1 or 2 Length of the string (character count, ln)
-1 or 2 1 Option flags:
- Bit Mask Contents
- 0 01H Character compression (ccompr):
- 0 = Compressed (8-bit characters)
- 1 = Uncompressed (16-bit characters)
- 2 04H Asian phonetic settings (phonetic):
- 0 = Does not contain Asian phonetic settings
- 1 = Contains Asian phonetic settings
- 3 08H Rich-Text settings (richtext):
- 0 = Does not contain Rich-Text settings
- 1 = Contains Rich-Text settings
-[2 or 3] 2 (optional, only if richtext=1) Number of Rich-Text formatting runs (rt)
-[var.] 4 (optional, only if phonetic=1) Size of Asian phonetic settings block (in bytes, sz)
-var. ln or
- 2·ln Character array (8-bit characters or 16-bit characters, dependent on ccompr)
-[var.] 4·rt (optional, only if richtext=1) List of rt formatting runs
-[var.] sz (optional, only if phonetic=1) Asian Phonetic Settings Block
-'''
-
-
-from struct import pack
-
-def upack2(s, encoding='ascii'):
- # If not unicode, make it so.
- if isinstance(s, unicode):
- us = s
- else:
- us = unicode(s, encoding)
- # Limit is based on number of content characters
- # (not on number of bytes in packed result)
- len_us = len(us)
- if len_us > 65535:
- raise Exception('String longer than 65535 characters')
- try:
- encs = us.encode('latin1')
- # Success here means all chars are in U+0000 to U+00FF
- # inclusive, meaning that we can use "compressed format".
- flag = 0
- except UnicodeEncodeError:
- encs = us.encode('utf_16_le')
- flag = 1
- return pack('<HB', len_us, flag) + encs
-
-def upack1(s, encoding='ascii'):
- # Same as upack2(), but with a one-byte length field.
- if isinstance(s, unicode):
- us = s
- else:
- us = unicode(s, encoding)
- len_us = len(us)
- if len_us > 255:
- raise Exception('String longer than 255 characters')
- try:
- encs = us.encode('latin1')
- flag = 0
- except UnicodeEncodeError:
- encs = us.encode('utf_16_le')
- flag = 1
- return pack('<BB', len_us, flag) + encs
diff --git a/tablib/packages/xlwt/Utils.py b/tablib/packages/xlwt/Utils.py deleted file mode 100644 index 90fb935..0000000 --- a/tablib/packages/xlwt/Utils.py +++ /dev/null @@ -1,196 +0,0 @@ -# pyXLWriter: A library for generating Excel Spreadsheets
-# Copyright (c) 2004 Evgeny Filatov <fufff@users.sourceforge.net>
-# Copyright (c) 2002-2004 John McNamara (Perl Spreadsheet::WriteExcel)
-#
-# This library is free software; you can redistribute it and/or modify it
-# under the terms of the GNU Lesser General Public License as published by
-# the Free Software Foundation; either version 2.1 of the License, or
-# (at your option) any later version.
-#
-# This library is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser
-# General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public License
-# along with this library; if not, write to the Free Software Foundation,
-# Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#----------------------------------------------------------------------------
-# This module was written/ported from PERL Spreadsheet::WriteExcel module
-# The author of the PERL Spreadsheet::WriteExcel module is John McNamara
-# <jmcnamara@cpan.org>
-#----------------------------------------------------------------------------
-# See the README.txt distributed with pyXLWriter for more details.
-
-# Portions are (C) Roman V. Kiseliov, 2005
-
-
-# Utilities for work with reference to cells and with sheetnames
-
-
-__rev_id__ = """$Id: Utils.py 3844 2009-05-20 01:02:54Z sjmachin $"""
-
-import re
-from struct import pack
-from ExcelMagic import MAX_ROW, MAX_COL
-
-
-_re_cell_ex = re.compile(r"(\$?)([A-I]?[A-Z])(\$?)(\d+)", re.IGNORECASE)
-_re_row_range = re.compile(r"\$?(\d+):\$?(\d+)")
-_re_col_range = re.compile(r"\$?([A-I]?[A-Z]):\$?([A-I]?[A-Z])", re.IGNORECASE)
-_re_cell_range = re.compile(r"\$?([A-I]?[A-Z]\$?\d+):\$?([A-I]?[A-Z]\$?\d+)", re.IGNORECASE)
-_re_cell_ref = re.compile(r"\$?([A-I]?[A-Z]\$?\d+)", re.IGNORECASE)
-
-
-def col_by_name(colname):
- """
- """
- col = 0
- pow = 1
- for i in xrange(len(colname)-1, -1, -1):
- ch = colname[i]
- col += (ord(ch) - ord('A') + 1) * pow
- pow *= 26
- return col - 1
-
-
-def cell_to_rowcol(cell):
- """Convert an Excel cell reference string in A1 notation
- to numeric row/col notation.
-
- Returns: row, col, row_abs, col_abs
-
- """
- m = _re_cell_ex.match(cell)
- if not m:
- raise Exception("Ill-formed single_cell reference: %s" % cell)
- col_abs, col, row_abs, row = m.groups()
- row_abs = bool(row_abs)
- col_abs = bool(col_abs)
- row = int(row) - 1
- col = col_by_name(col.upper())
- return row, col, row_abs, col_abs
-
-
-def cell_to_rowcol2(cell):
- """Convert an Excel cell reference string in A1 notation
- to numeric row/col notation.
-
- Returns: row, col
-
- """
- m = _re_cell_ex.match(cell)
- if not m:
- raise Exception("Error in cell format")
- col_abs, col, row_abs, row = m.groups()
- # Convert base26 column string to number
- # All your Base are belong to us.
- row = int(row) - 1
- col = col_by_name(col.upper())
- return row, col
-
-
-def rowcol_to_cell(row, col, row_abs=False, col_abs=False):
- """Convert numeric row/col notation to an Excel cell reference string in
- A1 notation.
-
- """
- assert 0 <= row < MAX_ROW # MAX_ROW counts from 1
- assert 0 <= col < MAX_COL # MAX_COL counts from 1
- d = col // 26
- m = col % 26
- chr1 = "" # Most significant character in AA1
- if row_abs:
- row_abs = '$'
- else:
- row_abs = ''
- if col_abs:
- col_abs = '$'
- else:
- col_abs = ''
- if d > 0:
- chr1 = chr(ord('A') + d - 1)
- chr2 = chr(ord('A') + m)
- # Zero index to 1-index
- return col_abs + chr1 + chr2 + row_abs + str(row + 1)
-
-def rowcol_pair_to_cellrange(row1, col1, row2, col2,
- row1_abs=False, col1_abs=False, row2_abs=False, col2_abs=False):
- """Convert two (row,column) pairs
- into a cell range string in A1:B2 notation.
-
- Returns: cell range string
- """
- assert row1 <= row2
- assert col1 <= col2
- return (
- rowcol_to_cell(row1, col1, row1_abs, col1_abs)
- + ":"
- + rowcol_to_cell(row2, col2, row2_abs, col2_abs)
- )
-
-def cellrange_to_rowcol_pair(cellrange):
- """Convert cell range string in A1 notation to numeric row/col
- pair.
-
- Returns: row1, col1, row2, col2
-
- """
- cellrange = cellrange.upper()
- # Convert a row range: '1:3'
- res = _re_row_range.match(cellrange)
- if res:
- row1 = int(res.group(1)) - 1
- col1 = 0
- row2 = int(res.group(2)) - 1
- col2 = -1
- return row1, col1, row2, col2
- # Convert a column range: 'A:A' or 'B:G'.
- # A range such as A:A is equivalent to A1:A16384, so add rows as required
- res = _re_col_range.match(cellrange)
- if res:
- col1 = col_by_name(res.group(1).upper())
- row1 = 0
- col2 = col_by_name(res.group(2).upper())
- row2 = -1
- return row1, col1, row2, col2
- # Convert a cell range: 'A1:B7'
- res = _re_cell_range.match(cellrange)
- if res:
- row1, col1 = cell_to_rowcol2(res.group(1))
- row2, col2 = cell_to_rowcol2(res.group(2))
- return row1, col1, row2, col2
- # Convert a cell reference: 'A1' or 'AD2000'
- res = _re_cell_ref.match(cellrange)
- if res:
- row1, col1 = cell_to_rowcol2(res.group(1))
- return row1, col1, row1, col1
- raise Exception("Unknown cell reference %s" % (cell))
-
-
-def cell_to_packed_rowcol(cell):
- """ pack row and column into the required 4 byte format """
- row, col, row_abs, col_abs = cell_to_rowcol(cell)
- if col >= MAX_COL:
- raise Exception("Column %s greater than IV in formula" % cell)
- if row >= MAX_ROW: # this for BIFF8. for BIFF7 available 2^14
- raise Exception("Row %s greater than %d in formula" % (cell, MAX_ROW))
- col |= int(not row_abs) << 15
- col |= int(not col_abs) << 14
- return row, col
-
-# === sheetname functions ===
-
-def valid_sheet_name(sheet_name):
- if sheet_name == u"" or sheet_name[0] == u"'" or len(sheet_name) > 31:
- return False
- for c in sheet_name:
- if c in u"[]:\\?/*\x00":
- return False
- return True
-
-def quote_sheet_name(unquoted_sheet_name):
- if not valid_sheet_name(unquoted_sheet_name):
- raise Exception(
- 'attempt to quote an invalid worksheet name %r' % unquoted_sheet_name)
- return u"'" + unquoted_sheet_name.replace(u"'", u"''") + u"'"
diff --git a/tablib/packages/xlwt/Workbook.py b/tablib/packages/xlwt/Workbook.py deleted file mode 100644 index d4e383a..0000000 --- a/tablib/packages/xlwt/Workbook.py +++ /dev/null @@ -1,636 +0,0 @@ -# -*- coding: windows-1252 -*-
-'''
-Record Order in BIFF8
- Workbook Globals Substream
- BOF Type = workbook globals
- Interface Header
- MMS
- Interface End
- WRITEACCESS
- CODEPAGE
- DSF
- TABID
- FNGROUPCOUNT
- Workbook Protection Block
- WINDOWPROTECT
- PROTECT
- PASSWORD
- PROT4REV
- PROT4REVPASS
- BACKUP
- HIDEOBJ
- WINDOW1
- DATEMODE
- PRECISION
- REFRESHALL
- BOOKBOOL
- FONT +
- FORMAT *
- XF +
- STYLE +
- ? PALETTE
- USESELFS
-
- BOUNDSHEET +
-
- COUNTRY
- ? Link Table
- SST
- ExtSST
- EOF
-'''
-
-import BIFFRecords
-import Style
-
-class Workbook(object):
-
- #################################################################
- ## Constructor
- #################################################################
- def __init__(self, encoding='ascii', style_compression=0):
- self.encoding = encoding
- self.__owner = 'None'
- self.__country_code = None # 0x07 is Russia :-)
- self.__wnd_protect = 0
- self.__obj_protect = 0
- self.__protect = 0
- self.__backup_on_save = 0
- # for WINDOW1 record
- self.__hpos_twips = 0x01E0
- self.__vpos_twips = 0x005A
- self.__width_twips = 0x3FCF
- self.__height_twips = 0x2A4E
-
- self.__active_sheet = 0
- self.__first_tab_index = 0
- self.__selected_tabs = 0x01
- self.__tab_width_twips = 0x0258
-
- self.__wnd_hidden = 0
- self.__wnd_mini = 0
- self.__hscroll_visible = 1
- self.__vscroll_visible = 1
- self.__tabs_visible = 1
-
- self.__styles = Style.StyleCollection(style_compression)
-
- self.__dates_1904 = 0
- self.__use_cell_values = 1
-
- self.__sst = BIFFRecords.SharedStringTable(self.encoding)
-
- self.__worksheets = []
- self.__worksheet_idx_from_name = {}
- self.__sheet_refs = {}
- self._supbook_xref = {}
- self._xcall_xref = {}
- self._ownbook_supbookx = None
- self._ownbook_supbook_ref = None
- self._xcall_supbookx = None
- self._xcall_supbook_ref = None
-
-
-
- #################################################################
- ## Properties, "getters", "setters"
- #################################################################
-
- def get_style_stats(self):
- return self.__styles.stats[:]
-
- def set_owner(self, value):
- self.__owner = value
-
- def get_owner(self):
- return self.__owner
-
- owner = property(get_owner, set_owner)
-
- #################################################################
-
- def set_country_code(self, value):
- self.__country_code = value
-
- def get_country_code(self):
- return self.__country_code
-
- country_code = property(get_country_code, set_country_code)
-
- #################################################################
-
- def set_wnd_protect(self, value):
- self.__wnd_protect = int(value)
-
- def get_wnd_protect(self):
- return bool(self.__wnd_protect)
-
- wnd_protect = property(get_wnd_protect, set_wnd_protect)
-
- #################################################################
-
- def set_obj_protect(self, value):
- self.__obj_protect = int(value)
-
- def get_obj_protect(self):
- return bool(self.__obj_protect)
-
- obj_protect = property(get_obj_protect, set_obj_protect)
-
- #################################################################
-
- def set_protect(self, value):
- self.__protect = int(value)
-
- def get_protect(self):
- return bool(self.__protect)
-
- protect = property(get_protect, set_protect)
-
- #################################################################
-
- def set_backup_on_save(self, value):
- self.__backup_on_save = int(value)
-
- def get_backup_on_save(self):
- return bool(self.__backup_on_save)
-
- backup_on_save = property(get_backup_on_save, set_backup_on_save)
-
- #################################################################
-
- def set_hpos(self, value):
- self.__hpos_twips = value & 0xFFFF
-
- def get_hpos(self):
- return self.__hpos_twips
-
- hpos = property(get_hpos, set_hpos)
-
- #################################################################
-
- def set_vpos(self, value):
- self.__vpos_twips = value & 0xFFFF
-
- def get_vpos(self):
- return self.__vpos_twips
-
- vpos = property(get_vpos, set_vpos)
-
- #################################################################
-
- def set_width(self, value):
- self.__width_twips = value & 0xFFFF
-
- def get_width(self):
- return self.__width_twips
-
- width = property(get_width, set_width)
-
- #################################################################
-
- def set_height(self, value):
- self.__height_twips = value & 0xFFFF
-
- def get_height(self):
- return self.__height_twips
-
- height = property(get_height, set_height)
-
- #################################################################
-
- def set_active_sheet(self, value):
- self.__active_sheet = value & 0xFFFF
- self.__first_tab_index = self.__active_sheet
-
- def get_active_sheet(self):
- return self.__active_sheet
-
- active_sheet = property(get_active_sheet, set_active_sheet)
-
- #################################################################
-
- def set_tab_width(self, value):
- self.__tab_width_twips = value & 0xFFFF
-
- def get_tab_width(self):
- return self.__tab_width_twips
-
- tab_width = property(get_tab_width, set_tab_width)
-
- #################################################################
-
- def set_wnd_visible(self, value):
- self.__wnd_hidden = int(not value)
-
- def get_wnd_visible(self):
- return not bool(self.__wnd_hidden)
-
- wnd_visible = property(get_wnd_visible, set_wnd_visible)
-
- #################################################################
-
- def set_wnd_mini(self, value):
- self.__wnd_mini = int(value)
-
- def get_wnd_mini(self):
- return bool(self.__wnd_mini)
-
- wnd_mini = property(get_wnd_mini, set_wnd_mini)
-
- #################################################################
-
- def set_hscroll_visible(self, value):
- self.__hscroll_visible = int(value)
-
- def get_hscroll_visible(self):
- return bool(self.__hscroll_visible)
-
- hscroll_visible = property(get_hscroll_visible, set_hscroll_visible)
-
- #################################################################
-
- def set_vscroll_visible(self, value):
- self.__vscroll_visible = int(value)
-
- def get_vscroll_visible(self):
- return bool(self.__vscroll_visible)
-
- vscroll_visible = property(get_vscroll_visible, set_vscroll_visible)
-
- #################################################################
-
- def set_tabs_visible(self, value):
- self.__tabs_visible = int(value)
-
- def get_tabs_visible(self):
- return bool(self.__tabs_visible)
-
- tabs_visible = property(get_tabs_visible, set_tabs_visible)
-
- #################################################################
-
- def set_dates_1904(self, value):
- self.__dates_1904 = int(value)
-
- def get_dates_1904(self):
- return bool(self.__dates_1904)
-
- dates_1904 = property(get_dates_1904, set_dates_1904)
-
- #################################################################
-
- def set_use_cell_values(self, value):
- self.__use_cell_values = int(value)
-
- def get_use_cell_values(self):
- return bool(self.__use_cell_values)
-
- use_cell_values = property(get_use_cell_values, set_use_cell_values)
-
- #################################################################
-
- def get_default_style(self):
- return self.__styles.default_style
-
- default_style = property(get_default_style)
-
- ##################################################################
- ## Methods
- ##################################################################
-
- def add_style(self, style):
- return self.__styles.add(style)
-
- def add_str(self, s):
- return self.__sst.add_str(s)
-
- def del_str(self, sst_idx):
- self.__sst.del_str(sst_idx)
-
- def str_index(self, s):
- return self.__sst.str_index(s)
-
- def add_sheet(self, sheetname, cell_overwrite_ok=False):
- import Worksheet, Utils
- if not isinstance(sheetname, unicode):
- sheetname = sheetname.decode(self.encoding)
- if not Utils.valid_sheet_name(sheetname):
- raise Exception("invalid worksheet name %r" % sheetname)
- lower_name = sheetname.lower()
- if lower_name in self.__worksheet_idx_from_name:
- raise Exception("duplicate worksheet name %r" % sheetname)
- self.__worksheet_idx_from_name[lower_name] = len(self.__worksheets)
- self.__worksheets.append(Worksheet.Worksheet(sheetname, self, cell_overwrite_ok))
- return self.__worksheets[-1]
-
- def get_sheet(self, sheetnum):
- return self.__worksheets[sheetnum]
-
- def raise_bad_sheetname(self, sheetname):
- raise Exception("Formula: unknown sheet name %s" % sheetname)
-
- def convert_sheetindex(self, strg_ref, n_sheets):
- idx = int(strg_ref)
- if 0 <= idx < n_sheets:
- return idx
- msg = "Formula: sheet index (%s) >= number of sheets (%d)" % (strg_ref, n_sheets)
- raise Exception(msg)
-
- def _get_supbook_index(self, tag):
- if tag in self._supbook_xref:
- return self._supbook_xref[tag]
- self._supbook_xref[tag] = idx = len(self._supbook_xref)
- return idx
-
- def setup_ownbook(self):
- self._ownbook_supbookx = self._get_supbook_index(('ownbook', 0))
- self._ownbook_supbook_ref = None
- reference = (self._ownbook_supbookx, 0xFFFE, 0xFFFE)
- if reference in self.__sheet_refs:
- raise Exception("can't happen")
- self.__sheet_refs[reference] = self._ownbook_supbook_ref = len(self.__sheet_refs)
-
- def setup_xcall(self):
- self._xcall_supbookx = self._get_supbook_index(('xcall', 0))
- self._xcall_supbook_ref = None
- reference = (self._xcall_supbookx, 0xFFFE, 0xFFFE)
- if reference in self.__sheet_refs:
- raise Exception("can't happen")
- self.__sheet_refs[reference] = self._xcall_supbook_ref = len(self.__sheet_refs)
-
- def add_sheet_reference(self, formula):
- patches = []
- n_sheets = len(self.__worksheets)
- sheet_refs, xcall_refs = formula.get_references()
-
- for ref0, ref1, offset in sheet_refs:
- if not ref0.isdigit():
- try:
- ref0n = self.__worksheet_idx_from_name[ref0.lower()]
- except KeyError:
- self.raise_bad_sheetname(ref0)
- else:
- ref0n = self.convert_sheetindex(ref0, n_sheets)
- if ref1 == ref0:
- ref1n = ref0n
- elif not ref1.isdigit():
- try:
- ref1n = self.__worksheet_idx_from_name[ref1.lower()]
- except KeyError:
- self.raise_bad_sheetname(ref1)
- else:
- ref1n = self.convert_sheetindex(ref1, n_sheets)
- if ref1n < ref0n:
- msg = "Formula: sheets out of order; %r:%r -> (%d, %d)" \
- % (ref0, ref1, ref0n, ref1n)
- raise Exception(msg)
- if self._ownbook_supbookx is None:
- self.setup_ownbook()
- reference = (self._ownbook_supbookx, ref0n, ref1n)
- if reference in self.__sheet_refs:
- patches.append((offset, self.__sheet_refs[reference]))
- else:
- nrefs = len(self.__sheet_refs)
- if nrefs > 65535:
- raise Exception('More than 65536 inter-sheet references')
- self.__sheet_refs[reference] = nrefs
- patches.append((offset, nrefs))
-
- for funcname, offset in xcall_refs:
- if self._ownbook_supbookx is None:
- self.setup_ownbook()
- if self._xcall_supbookx is None:
- self.setup_xcall()
- # print funcname, self._supbook_xref
- patches.append((offset, self._xcall_supbook_ref))
- if not isinstance(funcname, unicode):
- funcname = funcname.decode(self.encoding)
- if funcname in self._xcall_xref:
- idx = self._xcall_xref[funcname]
- else:
- self._xcall_xref[funcname] = idx = len(self._xcall_xref)
- patches.append((offset + 2, idx + 1))
-
- formula.patch_references(patches)
-
- ##################################################################
- ## BIFF records generation
- ##################################################################
-
- def __bof_rec(self):
- return BIFFRecords.Biff8BOFRecord(BIFFRecords.Biff8BOFRecord.BOOK_GLOBAL).get()
-
- def __eof_rec(self):
- return BIFFRecords.EOFRecord().get()
-
- def __intf_hdr_rec(self):
- return BIFFRecords.InteraceHdrRecord().get()
-
- def __intf_end_rec(self):
- return BIFFRecords.InteraceEndRecord().get()
-
- def __intf_mms_rec(self):
- return BIFFRecords.MMSRecord().get()
-
- def __write_access_rec(self):
- return BIFFRecords.WriteAccessRecord(self.__owner).get()
-
- def __wnd_protect_rec(self):
- return BIFFRecords.WindowProtectRecord(self.__wnd_protect).get()
-
- def __obj_protect_rec(self):
- return BIFFRecords.ObjectProtectRecord(self.__obj_protect).get()
-
- def __protect_rec(self):
- return BIFFRecords.ProtectRecord(self.__protect).get()
-
- def __password_rec(self):
- return BIFFRecords.PasswordRecord().get()
-
- def __prot4rev_rec(self):
- return BIFFRecords.Prot4RevRecord().get()
-
- def __prot4rev_pass_rec(self):
- return BIFFRecords.Prot4RevPassRecord().get()
-
- def __backup_rec(self):
- return BIFFRecords.BackupRecord(self.__backup_on_save).get()
-
- def __hide_obj_rec(self):
- return BIFFRecords.HideObjRecord().get()
-
- def __window1_rec(self):
- flags = 0
- flags |= (self.__wnd_hidden) << 0
- flags |= (self.__wnd_mini) << 1
- flags |= (self.__hscroll_visible) << 3
- flags |= (self.__vscroll_visible) << 4
- flags |= (self.__tabs_visible) << 5
-
- return BIFFRecords.Window1Record(self.__hpos_twips, self.__vpos_twips,
- self.__width_twips, self.__height_twips,
- flags,
- self.__active_sheet, self.__first_tab_index,
- self.__selected_tabs, self.__tab_width_twips).get()
-
- def __codepage_rec(self):
- return BIFFRecords.CodepageBiff8Record().get()
-
- def __country_rec(self):
- if not self.__country_code:
- return ''
- return BIFFRecords.CountryRecord(self.__country_code, self.__country_code).get()
-
- def __dsf_rec(self):
- return BIFFRecords.DSFRecord().get()
-
- def __tabid_rec(self):
- return BIFFRecords.TabIDRecord(len(self.__worksheets)).get()
-
- def __fngroupcount_rec(self):
- return BIFFRecords.FnGroupCountRecord().get()
-
- def __datemode_rec(self):
- return BIFFRecords.DateModeRecord(self.__dates_1904).get()
-
- def __precision_rec(self):
- return BIFFRecords.PrecisionRecord(self.__use_cell_values).get()
-
- def __refresh_all_rec(self):
- return BIFFRecords.RefreshAllRecord().get()
-
- def __bookbool_rec(self):
- return BIFFRecords.BookBoolRecord().get()
-
- def __all_fonts_num_formats_xf_styles_rec(self):
- return self.__styles.get_biff_data()
-
- def __palette_rec(self):
- result = ''
- return result
-
- def __useselfs_rec(self):
- return BIFFRecords.UseSelfsRecord().get()
-
- def __boundsheets_rec(self, data_len_before, data_len_after, sheet_biff_lens):
- # .................................
- # BOUNDSEHEET0
- # BOUNDSEHEET1
- # BOUNDSEHEET2
- # ..................................
- # WORKSHEET0
- # WORKSHEET1
- # WORKSHEET2
- boundsheets_len = 0
- for sheet in self.__worksheets:
- boundsheets_len += len(BIFFRecords.BoundSheetRecord(
- 0x00L, sheet.visibility, sheet.name, self.encoding
- ).get())
-
- start = data_len_before + boundsheets_len + data_len_after
-
- result = ''
- for sheet_biff_len, sheet in zip(sheet_biff_lens, self.__worksheets):
- result += BIFFRecords.BoundSheetRecord(
- start, sheet.visibility, sheet.name, self.encoding
- ).get()
- start += sheet_biff_len
- return result
-
- def __all_links_rec(self):
- pieces = []
- temp = [(idx, tag) for tag, idx in self._supbook_xref.items()]
- temp.sort()
- for idx, tag in temp:
- stype, snum = tag
- if stype == 'ownbook':
- rec = BIFFRecords.InternalReferenceSupBookRecord(len(self.__worksheets)).get()
- pieces.append(rec)
- elif stype == 'xcall':
- rec = BIFFRecords.XcallSupBookRecord().get()
- pieces.append(rec)
- temp = [(idx, name) for name, idx in self._xcall_xref.items()]
- temp.sort()
- for idx, name in temp:
- rec = BIFFRecords.ExternnameRecord(
- options=0, index=0, name=name, fmla='\x02\x00\x1c\x17').get()
- pieces.append(rec)
- else:
- raise Exception('unknown supbook stype %r' % stype)
- if len(self.__sheet_refs) > 0:
- # get references in index order
- temp = [(idx, ref) for ref, idx in self.__sheet_refs.items()]
- temp.sort()
- temp = [ref for idx, ref in temp]
- externsheet_record = BIFFRecords.ExternSheetRecord(temp).get()
- pieces.append(externsheet_record)
- return ''.join(pieces)
-
- def __sst_rec(self):
- return self.__sst.get_biff_record()
-
- def __ext_sst_rec(self, abs_stream_pos):
- return ''
- #return BIFFRecords.ExtSSTRecord(abs_stream_pos, self.sst_record.str_placement,
- #self.sst_record.portions_len).get()
-
- def get_biff_data(self):
- before = ''
- before += self.__bof_rec()
- before += self.__intf_hdr_rec()
- before += self.__intf_mms_rec()
- before += self.__intf_end_rec()
- before += self.__write_access_rec()
- before += self.__codepage_rec()
- before += self.__dsf_rec()
- before += self.__tabid_rec()
- before += self.__fngroupcount_rec()
- before += self.__wnd_protect_rec()
- before += self.__protect_rec()
- before += self.__obj_protect_rec()
- before += self.__password_rec()
- before += self.__prot4rev_rec()
- before += self.__prot4rev_pass_rec()
- before += self.__backup_rec()
- before += self.__hide_obj_rec()
- before += self.__window1_rec()
- before += self.__datemode_rec()
- before += self.__precision_rec()
- before += self.__refresh_all_rec()
- before += self.__bookbool_rec()
- before += self.__all_fonts_num_formats_xf_styles_rec()
- before += self.__palette_rec()
- before += self.__useselfs_rec()
-
- country = self.__country_rec()
- all_links = self.__all_links_rec()
-
- shared_str_table = self.__sst_rec()
- after = country + all_links + shared_str_table
-
- ext_sst = self.__ext_sst_rec(0) # need fake cause we need calc stream pos
- eof = self.__eof_rec()
-
- self.__worksheets[self.__active_sheet].selected = True
- sheets = ''
- sheet_biff_lens = []
- for sheet in self.__worksheets:
- data = sheet.get_biff_data()
- sheets += data
- sheet_biff_lens.append(len(data))
-
- bundlesheets = self.__boundsheets_rec(len(before), len(after)+len(ext_sst)+len(eof), sheet_biff_lens)
-
- sst_stream_pos = len(before) + len(bundlesheets) + len(country) + len(all_links)
- ext_sst = self.__ext_sst_rec(sst_stream_pos)
-
- return before + bundlesheets + after + ext_sst + eof + sheets
-
- def save(self, filename):
- import CompoundDoc
-
- doc = CompoundDoc.XlsDoc()
- doc.save(filename, self.get_biff_data())
-
-
diff --git a/tablib/packages/xlwt/Worksheet.py b/tablib/packages/xlwt/Worksheet.py deleted file mode 100644 index 67cf79a..0000000 --- a/tablib/packages/xlwt/Worksheet.py +++ /dev/null @@ -1,1297 +0,0 @@ -# -*- coding: windows-1252 -*-
-'''
- BOF
- UNCALCED
- INDEX
- Calculation Settings Block
- PRINTHEADERS
- PRINTGRIDLINES
- GRIDSET
- GUTS
- DEFAULTROWHEIGHT
- WSBOOL
- Page Settings Block
- Worksheet Protection Block
- DEFCOLWIDTH
- COLINFO
- SORT
- DIMENSIONS
- Row Blocks
- WINDOW2
- SCL
- PANE
- SELECTION
- STANDARDWIDTH
- MERGEDCELLS
- LABELRANGES
- PHONETIC
- Conditional Formatting Table
- Hyperlink Table
- Data Validity Table
- SHEETLAYOUT (BIFF8X only)
- SHEETPROTECTION (BIFF8X only)
- RANGEPROTECTION (BIFF8X only)
- EOF
-'''
-
-import BIFFRecords
-import Bitmap
-import Formatting
-import Style
-import tempfile
-
-
-class Worksheet(object):
- from Workbook import Workbook
-
- #################################################################
- ## Constructor
- #################################################################
- def __init__(self, sheetname, parent_book, cell_overwrite_ok=False):
- import Row
- self.Row = Row.Row
-
- import Column
- self.Column = Column.Column
-
- self.__name = sheetname
- self.__parent = parent_book
- self._cell_overwrite_ok = cell_overwrite_ok
-
- self.__rows = {}
- self.__cols = {}
- self.__merged_ranges = []
- self.__bmp_rec = ''
-
- self.__show_formulas = 0
- self.__show_grid = 1
- self.__show_headers = 1
- self.__panes_frozen = 0
- ### self.__show_empty_as_zero = 1 ### deprecated with extreme prejudice 2009-05-19
- self.show_zero_values = 1
- self.__auto_colour_grid = 1
- self.__cols_right_to_left = 0
- self.__show_outline = 1
- self.__remove_splits = 0
- self.__selected = 0
- # RED HERRING ALERT: "sheet_visible" is a clone of the "selected" attribute.
- # Typically a workbook created by the Excel UI will have one sheet
- # (the sheet that was selected when the user saved it)
- # with both bits set to 1, and all other sheets will have both
- # bits set to 0. The true visibility of the sheet is found in the "visibility"
- # attribute obtained from the BOUNDSHEET record.
- self.__sheet_visible = 0
- self.__page_preview = 0
-
- self.__first_visible_row = 0
- self.__first_visible_col = 0
- self.__grid_colour = 0x40
- self.__preview_magn = 60 # percent
- self.__normal_magn = 100 # percent
-
- self.visibility = 0 # from/to BOUNDSHEET record.
-
- self.__vert_split_pos = None
- self.__horz_split_pos = None
- self.__vert_split_first_visible = None
- self.__horz_split_first_visible = None
- self.__split_active_pane = None
-
- self.__row_gut_width = 0
- self.__col_gut_height = 0
-
- self.__show_auto_page_breaks = 1
- self.__dialogue_sheet = 0
- self.__auto_style_outline = 0
- self.__outline_below = 0
- self.__outline_right = 0
- self.__fit_num_pages = 0
- self.__show_row_outline = 1
- self.__show_col_outline = 1
- self.__alt_expr_eval = 0
- self.__alt_formula_entries = 0
-
- self.__row_default_height = 0x00FF
- self.row_default_height_mismatch = 0
- self.row_default_hidden = 0
- self.row_default_space_above = 0
- self.row_default_space_below = 0
-
- self.__col_default_width = 0x0008
-
- self.__calc_mode = 1
- self.__calc_count = 0x0064
- self.__RC_ref_mode = 1
- self.__iterations_on = 0
- self.__delta = 0.001
- self.__save_recalc = 0
-
- self.__print_headers = 0
- self.__print_grid = 0
- self.__grid_set = 1
- self.__vert_page_breaks = []
- self.__horz_page_breaks = []
- self.__header_str = '&P'
- self.__footer_str = '&F'
- self.__print_centered_vert = 0
- self.__print_centered_horz = 1
- self.__left_margin = 0.3 #0.5
- self.__right_margin = 0.3 #0.5
- self.__top_margin = 0.61 #1.0
- self.__bottom_margin = 0.37 #1.0
- self.__paper_size_code = 9 # A4
- self.__print_scaling = 100
- self.__start_page_number = 1
- self.__fit_width_to_pages = 1
- self.__fit_height_to_pages = 1
- self.__print_in_rows = 1
- self.__portrait = 1
- self.__print_not_colour = 0
- self.__print_draft = 0
- self.__print_notes = 0
- self.__print_notes_at_end = 0
- self.__print_omit_errors = 0
- self.__print_hres = 0x012C # 300 dpi
- self.__print_vres = 0x012C # 300 dpi
- self.__header_margin = 0.1
- self.__footer_margin = 0.1
- self.__copies_num = 1
-
- self.__wnd_protect = 0
- self.__obj_protect = 0
- self.__protect = 0
- self.__scen_protect = 0
- self.__password = ''
-
- self.last_used_row = 0
- self.first_used_row = 65535
- self.last_used_col = 0
- self.first_used_col = 255
- self.row_tempfile = None
- self.__flushed_rows = {}
- self.__row_visible_levels = 0
-
- #################################################################
- ## Properties, "getters", "setters"
- #################################################################
-
- def set_name(self, value):
- self.__name = value
-
- def get_name(self):
- return self.__name
-
- name = property(get_name, set_name)
-
- #################################################################
-
- def get_parent(self):
- return self.__parent
-
- parent = property(get_parent)
-
- #################################################################
-
- def get_rows(self):
- return self.__rows
-
- rows = property(get_rows)
-
- #################################################################
-
- def get_cols(self):
- return self.__cols
-
- cols = property(get_cols)
-
- #################################################################
-
- def get_merged_ranges(self):
- return self.__merged_ranges
-
- merged_ranges = property(get_merged_ranges)
-
- #################################################################
-
- def get_bmp_rec(self):
- return self.__bmp_rec
-
- bmp_rec = property(get_bmp_rec)
-
- #################################################################
-
- def set_show_formulas(self, value):
- self.__show_formulas = int(value)
-
- def get_show_formulas(self):
- return bool(self.__show_formulas)
-
- show_formulas = property(get_show_formulas, set_show_formulas)
-
- #################################################################
-
- def set_show_grid(self, value):
- self.__show_grid = int(value)
-
- def get_show_grid(self):
- return bool(self.__show_grid)
-
- show_grid = property(get_show_grid, set_show_grid)
-
- #################################################################
-
- def set_show_headers(self, value):
- self.__show_headers = int(value)
-
- def get_show_headers(self):
- return bool(self.__show_headers)
-
- show_headers = property(get_show_headers, set_show_headers)
-
- #################################################################
-
- def set_panes_frozen(self, value):
- self.__panes_frozen = int(value)
-
- def get_panes_frozen(self):
- return bool(self.__panes_frozen)
-
- panes_frozen = property(get_panes_frozen, set_panes_frozen)
-
- #################################################################
-
- ### def set_show_empty_as_zero(self, value):
- ### self.__show_empty_as_zero = int(value)
-
- ### def get_show_empty_as_zero(self):
- ### return bool(self.__show_empty_as_zero)
-
- ### show_empty_as_zero = property(get_show_empty_as_zero, set_show_empty_as_zero)
-
- #################################################################
-
- def set_auto_colour_grid(self, value):
- self.__auto_colour_grid = int(value)
-
- def get_auto_colour_grid(self):
- return bool(self.__auto_colour_grid)
-
- auto_colour_grid = property(get_auto_colour_grid, set_auto_colour_grid)
-
- #################################################################
-
- def set_cols_right_to_left(self, value):
- self.__cols_right_to_left = int(value)
-
- def get_cols_right_to_left(self):
- return bool(self.__cols_right_to_left)
-
- cols_right_to_left = property(get_cols_right_to_left, set_cols_right_to_left)
-
- #################################################################
-
- def set_show_outline(self, value):
- self.__show_outline = int(value)
-
- def get_show_outline(self):
- return bool(self.__show_outline)
-
- show_outline = property(get_show_outline, set_show_outline)
-
- #################################################################
-
- def set_remove_splits(self, value):
- self.__remove_splits = int(value)
-
- def get_remove_splits(self):
- return bool(self.__remove_splits)
-
- remove_splits = property(get_remove_splits, set_remove_splits)
-
- #################################################################
-
- def set_selected(self, value):
- self.__selected = int(value)
-
- def get_selected(self):
- return bool(self.__selected)
-
- selected = property(get_selected, set_selected)
-
- #################################################################
-
- def set_sheet_visible(self, value):
- self.__sheet_visible = int(value)
-
- def get_sheet_visible(self):
- return bool(self.__sheet_visible)
-
- sheet_visible = property(get_sheet_visible, set_sheet_visible)
-
- #################################################################
-
- def set_page_preview(self, value):
- self.__page_preview = int(value)
-
- def get_page_preview(self):
- return bool(self.__page_preview)
-
- page_preview = property(get_page_preview, set_page_preview)
-
- #################################################################
-
- def set_first_visible_row(self, value):
- self.__first_visible_row = value
-
- def get_first_visible_row(self):
- return self.__first_visible_row
-
- first_visible_row = property(get_first_visible_row, set_first_visible_row)
-
- #################################################################
-
- def set_first_visible_col(self, value):
- self.__first_visible_col = value
-
- def get_first_visible_col(self):
- return self.__first_visible_col
-
- first_visible_col = property(get_first_visible_col, set_first_visible_col)
-
- #################################################################
-
- def set_grid_colour(self, value):
- self.__grid_colour = value
-
- def get_grid_colour(self):
- return self.__grid_colour
-
- grid_colour = property(get_grid_colour, set_grid_colour)
-
- #################################################################
-
- def set_preview_magn(self, value):
- self.__preview_magn = value
-
- def get_preview_magn(self):
- return self.__preview_magn
-
- preview_magn = property(get_preview_magn, set_preview_magn)
-
- #################################################################
-
- def set_normal_magn(self, value):
- self.__normal_magn = value
-
- def get_normal_magn(self):
- return self.__normal_magn
-
- normal_magn = property(get_normal_magn, set_normal_magn)
-
- #################################################################
-
- def set_vert_split_pos(self, value):
- self.__vert_split_pos = abs(value)
-
- def get_vert_split_pos(self):
- return self.__vert_split_pos
-
- vert_split_pos = property(get_vert_split_pos, set_vert_split_pos)
-
- #################################################################
-
- def set_horz_split_pos(self, value):
- self.__horz_split_pos = abs(value)
-
- def get_horz_split_pos(self):
- return self.__horz_split_pos
-
- horz_split_pos = property(get_horz_split_pos, set_horz_split_pos)
-
- #################################################################
-
- def set_vert_split_first_visible(self, value):
- self.__vert_split_first_visible = abs(value)
-
- def get_vert_split_first_visible(self):
- return self.__vert_split_first_visible
-
- vert_split_first_visible = property(get_vert_split_first_visible, set_vert_split_first_visible)
-
- #################################################################
-
- def set_horz_split_first_visible(self, value):
- self.__horz_split_first_visible = abs(value)
-
- def get_horz_split_first_visible(self):
- return self.__horz_split_first_visible
-
- horz_split_first_visible = property(get_horz_split_first_visible, set_horz_split_first_visible)
-
- #################################################################
-
- #def set_split_active_pane(self, value):
- # self.__split_active_pane = abs(value) & 0x03
- #
- #def get_split_active_pane(self):
- # return self.__split_active_pane
- #
- #split_active_pane = property(get_split_active_pane, set_split_active_pane)
-
- #################################################################
-
- #def set_row_gut_width(self, value):
- # self.__row_gut_width = value
- #
- #def get_row_gut_width(self):
- # return self.__row_gut_width
- #
- #row_gut_width = property(get_row_gut_width, set_row_gut_width)
- #
- #################################################################
- #
- #def set_col_gut_height(self, value):
- # self.__col_gut_height = value
- #
- #def get_col_gut_height(self):
- # return self.__col_gut_height
- #
- #col_gut_height = property(get_col_gut_height, set_col_gut_height)
- #
- #################################################################
-
- def set_show_auto_page_breaks(self, value):
- self.__show_auto_page_breaks = int(value)
-
- def get_show_auto_page_breaks(self):
- return bool(self.__show_auto_page_breaks)
-
- show_auto_page_breaks = property(get_show_auto_page_breaks, set_show_auto_page_breaks)
-
- #################################################################
-
- def set_dialogue_sheet(self, value):
- self.__dialogue_sheet = int(value)
-
- def get_dialogue_sheet(self):
- return bool(self.__dialogue_sheet)
-
- dialogue_sheet = property(get_dialogue_sheet, set_dialogue_sheet)
-
- #################################################################
-
- def set_auto_style_outline(self, value):
- self.__auto_style_outline = int(value)
-
- def get_auto_style_outline(self):
- return bool(self.__auto_style_outline)
-
- auto_style_outline = property(get_auto_style_outline, set_auto_style_outline)
-
- #################################################################
-
- def set_outline_below(self, value):
- self.__outline_below = int(value)
-
- def get_outline_below(self):
- return bool(self.__outline_below)
-
- outline_below = property(get_outline_below, set_outline_below)
-
- #################################################################
-
- def set_outline_right(self, value):
- self.__outline_right = int(value)
-
- def get_outline_right(self):
- return bool(self.__outline_right)
-
- outline_right = property(get_outline_right, set_outline_right)
-
- #################################################################
-
- def set_fit_num_pages(self, value):
- self.__fit_num_pages = value
-
- def get_fit_num_pages(self):
- return self.__fit_num_pages
-
- fit_num_pages = property(get_fit_num_pages, set_fit_num_pages)
-
- #################################################################
-
- def set_show_row_outline(self, value):
- self.__show_row_outline = int(value)
-
- def get_show_row_outline(self):
- return bool(self.__show_row_outline)
-
- show_row_outline = property(get_show_row_outline, set_show_row_outline)
-
- #################################################################
-
- def set_show_col_outline(self, value):
- self.__show_col_outline = int(value)
-
- def get_show_col_outline(self):
- return bool(self.__show_col_outline)
-
- show_col_outline = property(get_show_col_outline, set_show_col_outline)
-
- #################################################################
-
- def set_alt_expr_eval(self, value):
- self.__alt_expr_eval = int(value)
-
- def get_alt_expr_eval(self):
- return bool(self.__alt_expr_eval)
-
- alt_expr_eval = property(get_alt_expr_eval, set_alt_expr_eval)
-
- #################################################################
-
- def set_alt_formula_entries(self, value):
- self.__alt_formula_entries = int(value)
-
- def get_alt_formula_entries(self):
- return bool(self.__alt_formula_entries)
-
- alt_formula_entries = property(get_alt_formula_entries, set_alt_formula_entries)
-
- #################################################################
-
- def set_row_default_height(self, value):
- self.__row_default_height = value
-
- def get_row_default_height(self):
- return self.__row_default_height
-
- row_default_height = property(get_row_default_height, set_row_default_height)
-
- #################################################################
-
- def set_col_default_width(self, value):
- self.__col_default_width = value
-
- def get_col_default_width(self):
- return self.__col_default_width
-
- col_default_width = property(get_col_default_width, set_col_default_width)
-
- #################################################################
-
- def set_calc_mode(self, value):
- self.__calc_mode = value & 0x03
-
- def get_calc_mode(self):
- return self.__calc_mode
-
- calc_mode = property(get_calc_mode, set_calc_mode)
-
- #################################################################
-
- def set_calc_count(self, value):
- self.__calc_count = value
-
- def get_calc_count(self):
- return self.__calc_count
-
- calc_count = property(get_calc_count, set_calc_count)
-
- #################################################################
-
- def set_RC_ref_mode(self, value):
- self.__RC_ref_mode = int(value)
-
- def get_RC_ref_mode(self):
- return bool(self.__RC_ref_mode)
-
- RC_ref_mode = property(get_RC_ref_mode, set_RC_ref_mode)
-
- #################################################################
-
- def set_iterations_on(self, value):
- self.__iterations_on = int(value)
-
- def get_iterations_on(self):
- return bool(self.__iterations_on)
-
- iterations_on = property(get_iterations_on, set_iterations_on)
-
- #################################################################
-
- def set_delta(self, value):
- self.__delta = value
-
- def get_delta(self):
- return self.__delta
-
- delta = property(get_delta, set_delta)
-
- #################################################################
-
- def set_save_recalc(self, value):
- self.__save_recalc = int(value)
-
- def get_save_recalc(self):
- return bool(self.__save_recalc)
-
- save_recalc = property(get_save_recalc, set_save_recalc)
-
- #################################################################
-
- def set_print_headers(self, value):
- self.__print_headers = int(value)
-
- def get_print_headers(self):
- return bool(self.__print_headers)
-
- print_headers = property(get_print_headers, set_print_headers)
-
- #################################################################
-
- def set_print_grid(self, value):
- self.__print_grid = int(value)
-
- def get_print_grid(self):
- return bool(self.__print_grid)
-
- print_grid = property(get_print_grid, set_print_grid)
-
- #################################################################
- #
- #def set_grid_set(self, value):
- # self.__grid_set = int(value)
- #
- #def get_grid_set(self):
- # return bool(self.__grid_set)
- #
- #grid_set = property(get_grid_set, set_grid_set)
- #
- #################################################################
-
- def set_vert_page_breaks(self, value):
- self.__vert_page_breaks = value
-
- def get_vert_page_breaks(self):
- return self.__vert_page_breaks
-
- vert_page_breaks = property(get_vert_page_breaks, set_vert_page_breaks)
-
- #################################################################
-
- def set_horz_page_breaks(self, value):
- self.__horz_page_breaks = value
-
- def get_horz_page_breaks(self):
- return self.__horz_page_breaks
-
- horz_page_breaks = property(get_horz_page_breaks, set_horz_page_breaks)
-
- #################################################################
-
- def set_header_str(self, value):
- if isinstance(value, str):
- value = unicode(value, self.__parent.encoding)
- self.__header_str = value
-
- def get_header_str(self):
- return self.__header_str
-
- header_str = property(get_header_str, set_header_str)
-
- #################################################################
-
- def set_footer_str(self, value):
- if isinstance(value, str):
- value = unicode(value, self.__parent.encoding)
- self.__footer_str = value
-
- def get_footer_str(self):
- return self.__footer_str
-
- footer_str = property(get_footer_str, set_footer_str)
-
- #################################################################
-
- def set_print_centered_vert(self, value):
- self.__print_centered_vert = int(value)
-
- def get_print_centered_vert(self):
- return bool(self.__print_centered_vert)
-
- print_centered_vert = property(get_print_centered_vert, set_print_centered_vert)
-
- #################################################################
-
- def set_print_centered_horz(self, value):
- self.__print_centered_horz = int(value)
-
- def get_print_centered_horz(self):
- return bool(self.__print_centered_horz)
-
- print_centered_horz = property(get_print_centered_horz, set_print_centered_horz)
-
- #################################################################
-
- def set_left_margin(self, value):
- self.__left_margin = value
-
- def get_left_margin(self):
- return self.__left_margin
-
- left_margin = property(get_left_margin, set_left_margin)
-
- #################################################################
-
- def set_right_margin(self, value):
- self.__right_margin = value
-
- def get_right_margin(self):
- return self.__right_margin
-
- right_margin = property(get_right_margin, set_right_margin)
-
- #################################################################
-
- def set_top_margin(self, value):
- self.__top_margin = value
-
- def get_top_margin(self):
- return self.__top_margin
-
- top_margin = property(get_top_margin, set_top_margin)
-
- #################################################################
-
- def set_bottom_margin(self, value):
- self.__bottom_margin = value
-
- def get_bottom_margin(self):
- return self.__bottom_margin
-
- bottom_margin = property(get_bottom_margin, set_bottom_margin)
-
- #################################################################
-
- def set_paper_size_code(self, value):
- self.__paper_size_code = value
-
- def get_paper_size_code(self):
- return self.__paper_size_code
-
- paper_size_code = property(get_paper_size_code, set_paper_size_code)
-
- #################################################################
-
- def set_print_scaling(self, value):
- self.__print_scaling = value
-
- def get_print_scaling(self):
- return self.__print_scaling
-
- print_scaling = property(get_print_scaling, set_print_scaling)
-
- #################################################################
-
- def set_start_page_number(self, value):
- self.__start_page_number = value
-
- def get_start_page_number(self):
- return self.__start_page_number
-
- start_page_number = property(get_start_page_number, set_start_page_number)
-
- #################################################################
-
- def set_fit_width_to_pages(self, value):
- self.__fit_width_to_pages = value
-
- def get_fit_width_to_pages(self):
- return self.__fit_width_to_pages
-
- fit_width_to_pages = property(get_fit_width_to_pages, set_fit_width_to_pages)
-
- #################################################################
-
- def set_fit_height_to_pages(self, value):
- self.__fit_height_to_pages = value
-
- def get_fit_height_to_pages(self):
- return self.__fit_height_to_pages
-
- fit_height_to_pages = property(get_fit_height_to_pages, set_fit_height_to_pages)
-
- #################################################################
-
- def set_print_in_rows(self, value):
- self.__print_in_rows = int(value)
-
- def get_print_in_rows(self):
- return bool(self.__print_in_rows)
-
- print_in_rows = property(get_print_in_rows, set_print_in_rows)
-
- #################################################################
-
- def set_portrait(self, value):
- self.__portrait = int(value)
-
- def get_portrait(self):
- return bool(self.__portrait)
-
- portrait = property(get_portrait, set_portrait)
-
- #################################################################
-
- def set_print_colour(self, value):
- self.__print_not_colour = int(not value)
-
- def get_print_colour(self):
- return not bool(self.__print_not_colour)
-
- print_colour = property(get_print_colour, set_print_colour)
-
- #################################################################
-
- def set_print_draft(self, value):
- self.__print_draft = int(value)
-
- def get_print_draft(self):
- return bool(self.__print_draft)
-
- print_draft = property(get_print_draft, set_print_draft)
-
- #################################################################
-
- def set_print_notes(self, value):
- self.__print_notes = int(value)
-
- def get_print_notes(self):
- return bool(self.__print_notes)
-
- print_notes = property(get_print_notes, set_print_notes)
-
- #################################################################
-
- def set_print_notes_at_end(self, value):
- self.__print_notes_at_end = int(value)
-
- def get_print_notes_at_end(self):
- return bool(self.__print_notes_at_end)
-
- print_notes_at_end = property(get_print_notes_at_end, set_print_notes_at_end)
-
- #################################################################
-
- def set_print_omit_errors(self, value):
- self.__print_omit_errors = int(value)
-
- def get_print_omit_errors(self):
- return bool(self.__print_omit_errors)
-
- print_omit_errors = property(get_print_omit_errors, set_print_omit_errors)
-
- #################################################################
-
- def set_print_hres(self, value):
- self.__print_hres = value
-
- def get_print_hres(self):
- return self.__print_hres
-
- print_hres = property(get_print_hres, set_print_hres)
-
- #################################################################
-
- def set_print_vres(self, value):
- self.__print_vres = value
-
- def get_print_vres(self):
- return self.__print_vres
-
- print_vres = property(get_print_vres, set_print_vres)
-
- #################################################################
-
- def set_header_margin(self, value):
- self.__header_margin = value
-
- def get_header_margin(self):
- return self.__header_margin
-
- header_margin = property(get_header_margin, set_header_margin)
-
- #################################################################
-
- def set_footer_margin(self, value):
- self.__footer_margin = value
-
- def get_footer_margin(self):
- return self.__footer_margin
-
- footer_margin = property(get_footer_margin, set_footer_margin)
-
- #################################################################
-
- def set_copies_num(self, value):
- self.__copies_num = value
-
- def get_copies_num(self):
- return self.__copies_num
-
- copies_num = property(get_copies_num, set_copies_num)
-
- ##################################################################
-
- def set_wnd_protect(self, value):
- self.__wnd_protect = int(value)
-
- def get_wnd_protect(self):
- return bool(self.__wnd_protect)
-
- wnd_protect = property(get_wnd_protect, set_wnd_protect)
-
- #################################################################
-
- def set_obj_protect(self, value):
- self.__obj_protect = int(value)
-
- def get_obj_protect(self):
- return bool(self.__obj_protect)
-
- obj_protect = property(get_obj_protect, set_obj_protect)
-
- #################################################################
-
- def set_protect(self, value):
- self.__protect = int(value)
-
- def get_protect(self):
- return bool(self.__protect)
-
- protect = property(get_protect, set_protect)
-
- #################################################################
-
- def set_scen_protect(self, value):
- self.__scen_protect = int(value)
-
- def get_scen_protect(self):
- return bool(self.__scen_protect)
-
- scen_protect = property(get_scen_protect, set_scen_protect)
-
- #################################################################
-
- def set_password(self, value):
- self.__password = value
-
- def get_password(self):
- return self.__password
-
- password = property(get_password, set_password)
-
- ##################################################################
- ## Methods
- ##################################################################
-
- def get_parent(self):
- return self.__parent
-
- def write(self, r, c, label="", style=Style.default_style):
- self.row(r).write(c, label, style)
-
- def merge(self, r1, r2, c1, c2, style=Style.default_style):
- # Stand-alone merge of previously written cells.
- # Problems: (1) style to be used should be existing style of
- # the top-left cell, not an arg.
- # (2) should ensure that any previous data value in
- # non-top-left cells is nobbled.
- # Note: if a cell is set by a data record then later
- # is referenced by a [MUL]BLANK record, Excel will blank
- # out the cell on the screen, but OOo & Gnu will not
- # blank it out. Need to do something better than writing
- # multiple records. In the meantime, avoid this method and use
- # write_merge() instead.
- if c2 > c1:
- self.row(r1).write_blanks(c1 + 1, c2, style)
- for r in range(r1+1, r2+1):
- self.row(r).write_blanks(c1, c2, style)
- self.__merged_ranges.append((r1, r2, c1, c2))
-
- def write_merge(self, r1, r2, c1, c2, label="", style=Style.default_style):
- assert 0 <= c1 <= c2 <= 255
- assert 0 <= r1 <= r2 <= 65535
- self.write(r1, c1, label, style)
- if c2 > c1:
- self.row(r1).write_blanks(c1 + 1, c2, style) # skip (r1, c1)
- for r in range(r1+1, r2+1):
- self.row(r).write_blanks(c1, c2, style)
- self.__merged_ranges.append((r1, r2, c1, c2))
-
- def insert_bitmap(self, filename, row, col, x = 0, y = 0, scale_x = 1, scale_y = 1):
- bmp = Bitmap.ImDataBmpRecord(filename)
- obj = Bitmap.ObjBmpRecord(row, col, self, bmp, x, y, scale_x, scale_y)
-
- self.__bmp_rec += obj.get() + bmp.get()
-
- def col(self, indx):
- if indx not in self.__cols:
- self.__cols[indx] = self.Column(indx, self)
- return self.__cols[indx]
-
- def row(self, indx):
- if indx not in self.__rows:
- if indx in self.__flushed_rows:
- raise Exception("Attempt to reuse row index %d of sheet %r after flushing" % (indx, self.__name))
- self.__rows[indx] = self.Row(indx, self)
- if indx > self.last_used_row:
- self.last_used_row = indx
- if indx < self.first_used_row:
- self.first_used_row = indx
- return self.__rows[indx]
-
- def row_height(self, row): # in pixels
- if row in self.__rows:
- return self.__rows[row].get_height_in_pixels()
- else:
- return 17
-
- def col_width(self, col): # in pixels
- if col in self.__cols:
- return self.__cols[col].width_in_pixels()
- else:
- return 64
-
-
- ##################################################################
- ## BIFF records generation
- ##################################################################
-
- def __bof_rec(self):
- return BIFFRecords.Biff8BOFRecord(BIFFRecords.Biff8BOFRecord.WORKSHEET).get()
-
- def __update_row_visible_levels(self):
- if self.__rows:
- temp = max([self.__rows[r].level for r in self.__rows]) + 1
- self.__row_visible_levels = max(temp, self.__row_visible_levels)
-
- def __guts_rec(self):
- self.__update_row_visible_levels()
- col_visible_levels = 0
- if len(self.__cols) != 0:
- col_visible_levels = max([self.__cols[c].level for c in self.__cols]) + 1
- return BIFFRecords.GutsRecord(
- self.__row_gut_width, self.__col_gut_height, self.__row_visible_levels, col_visible_levels).get()
-
- def __defaultrowheight_rec(self):
- options = 0x0000
- options |= (self.row_default_height_mismatch & 1) << 0
- options |= (self.row_default_hidden & 1) << 1
- options |= (self.row_default_space_above & 1) << 2
- options |= (self.row_default_space_below & 1) << 3
- defht = self.__row_default_height
- return BIFFRecords.DefaultRowHeightRecord(options, defht).get()
-
- def __wsbool_rec(self):
- options = 0x00
- options |= (self.__show_auto_page_breaks & 0x01) << 0
- options |= (self.__dialogue_sheet & 0x01) << 4
- options |= (self.__auto_style_outline & 0x01) << 5
- options |= (self.__outline_below & 0x01) << 6
- options |= (self.__outline_right & 0x01) << 7
- options |= (self.__fit_num_pages & 0x01) << 8
- options |= (self.__show_row_outline & 0x01) << 10
- options |= (self.__show_col_outline & 0x01) << 11
- options |= (self.__alt_expr_eval & 0x01) << 14
- options |= (self.__alt_formula_entries & 0x01) << 15
-
- return BIFFRecords.WSBoolRecord(options).get()
-
- def __eof_rec(self):
- return BIFFRecords.EOFRecord().get()
-
- def __colinfo_rec(self):
- result = ''
- for col in self.__cols:
- result += self.__cols[col].get_biff_record()
- return result
-
- def __dimensions_rec(self):
- return BIFFRecords.DimensionsRecord(
- self.first_used_row, self.last_used_row,
- self.first_used_col, self.last_used_col
- ).get()
-
- def __window2_rec(self):
- # Appends SCL record.
- options = 0
- options |= (self.__show_formulas & 0x01) << 0
- options |= (self.__show_grid & 0x01) << 1
- options |= (self.__show_headers & 0x01) << 2
- options |= (self.__panes_frozen & 0x01) << 3
- options |= (self.show_zero_values & 0x01) << 4
- options |= (self.__auto_colour_grid & 0x01) << 5
- options |= (self.__cols_right_to_left & 0x01) << 6
- options |= (self.__show_outline & 0x01) << 7
- options |= (self.__remove_splits & 0x01) << 8
- options |= (self.__selected & 0x01) << 9
- options |= (self.__sheet_visible & 0x01) << 10
- options |= (self.__page_preview & 0x01) << 11
- if self.__page_preview:
- scl_magn = self.__preview_magn
- else:
- scl_magn = self.__normal_magn
- return BIFFRecords.Window2Record(
- options, self.__first_visible_row, self.__first_visible_col,
- self.__grid_colour,
- self.__preview_magn, self.__normal_magn, scl_magn).get()
-
- def __panes_rec(self):
- if self.__vert_split_pos is None and self.__horz_split_pos is None:
- return ""
-
- if self.__vert_split_pos is None:
- self.__vert_split_pos = 0
- if self.__horz_split_pos is None:
- self.__horz_split_pos = 0
-
- if self.__panes_frozen:
- if self.__vert_split_first_visible is None:
- self.__vert_split_first_visible = self.__vert_split_pos
- if self.__horz_split_first_visible is None:
- self.__horz_split_first_visible = self.__horz_split_pos
- else:
- if self.__vert_split_first_visible is None:
- self.__vert_split_first_visible = 0
- if self.__horz_split_first_visible is None:
- self.__horz_split_first_visible = 0
- # inspired by pyXLWriter
- self.__horz_split_pos = 20*self.__horz_split_pos + 255
- self.__vert_split_pos = 113.879*self.__vert_split_pos + 390
-
- if self.__vert_split_pos > 0 and self.__horz_split_pos > 0:
- self.__split_active_pane = 0
- elif self.__vert_split_pos > 0 and self.__horz_split_pos == 0:
- self.__split_active_pane = 1
- elif self.__vert_split_pos == 0 and self.__horz_split_pos > 0:
- self.__split_active_pane = 2
- else:
- self.__split_active_pane = 3
-
- result = BIFFRecords.PanesRecord(self.__vert_split_pos,
- self.__horz_split_pos,
- self.__horz_split_first_visible,
- self.__vert_split_first_visible,
- self.__split_active_pane).get()
- return result
-
- def __row_blocks_rec(self):
- result = []
- for row in self.__rows.itervalues():
- result.append(row.get_row_biff_data())
- result.append(row.get_cells_biff_data())
- return ''.join(result)
-
- def __merged_rec(self):
- return BIFFRecords.MergedCellsRecord(self.__merged_ranges).get()
-
- def __bitmaps_rec(self):
- return self.__bmp_rec
-
- def __calc_settings_rec(self):
- result = ''
- result += BIFFRecords.CalcModeRecord(self.__calc_mode & 0x01).get()
- result += BIFFRecords.CalcCountRecord(self.__calc_count & 0xFFFF).get()
- result += BIFFRecords.RefModeRecord(self.__RC_ref_mode & 0x01).get()
- result += BIFFRecords.IterationRecord(self.__iterations_on & 0x01).get()
- result += BIFFRecords.DeltaRecord(self.__delta).get()
- result += BIFFRecords.SaveRecalcRecord(self.__save_recalc & 0x01).get()
- return result
-
- def __print_settings_rec(self):
- result = ''
- result += BIFFRecords.PrintHeadersRecord(self.__print_headers).get()
- result += BIFFRecords.PrintGridLinesRecord(self.__print_grid).get()
- result += BIFFRecords.GridSetRecord(self.__grid_set).get()
- result += BIFFRecords.HorizontalPageBreaksRecord(self.__horz_page_breaks).get()
- result += BIFFRecords.VerticalPageBreaksRecord(self.__vert_page_breaks).get()
- result += BIFFRecords.HeaderRecord(self.__header_str).get()
- result += BIFFRecords.FooterRecord(self.__footer_str).get()
- result += BIFFRecords.HCenterRecord(self.__print_centered_horz).get()
- result += BIFFRecords.VCenterRecord(self.__print_centered_vert).get()
- result += BIFFRecords.LeftMarginRecord(self.__left_margin).get()
- result += BIFFRecords.RightMarginRecord(self.__right_margin).get()
- result += BIFFRecords.TopMarginRecord(self.__top_margin).get()
- result += BIFFRecords.BottomMarginRecord(self.__bottom_margin).get()
-
- setup_page_options = (self.__print_in_rows & 0x01) << 0
- setup_page_options |= (self.__portrait & 0x01) << 1
- setup_page_options |= (0x00 & 0x01) << 2
- setup_page_options |= (self.__print_not_colour & 0x01) << 3
- setup_page_options |= (self.__print_draft & 0x01) << 4
- setup_page_options |= (self.__print_notes & 0x01) << 5
- setup_page_options |= (0x00 & 0x01) << 6
- setup_page_options |= (0x01 & 0x01) << 7
- setup_page_options |= (self.__print_notes_at_end & 0x01) << 9
- setup_page_options |= (self.__print_omit_errors & 0x03) << 10
-
- result += BIFFRecords.SetupPageRecord(self.__paper_size_code,
- self.__print_scaling,
- self.__start_page_number,
- self.__fit_width_to_pages,
- self.__fit_height_to_pages,
- setup_page_options,
- self.__print_hres,
- self.__print_vres,
- self.__header_margin,
- self.__footer_margin,
- self.__copies_num).get()
- return result
-
- def __protection_rec(self):
- result = ''
- result += BIFFRecords.ProtectRecord(self.__protect).get()
- result += BIFFRecords.ScenProtectRecord(self.__scen_protect).get()
- result += BIFFRecords.WindowProtectRecord(self.__wnd_protect).get()
- result += BIFFRecords.ObjectProtectRecord(self.__obj_protect).get()
- result += BIFFRecords.PasswordRecord(self.__password).get()
- return result
-
- def get_biff_data(self):
- result = [
- self.__bof_rec(),
- self.__calc_settings_rec(),
- self.__guts_rec(),
- self.__defaultrowheight_rec(),
- self.__wsbool_rec(),
- self.__colinfo_rec(),
- self.__dimensions_rec(),
- self.__print_settings_rec(),
- self.__protection_rec(),
- ]
- if self.row_tempfile:
- self.row_tempfile.flush()
- self.row_tempfile.seek(0)
- result.append(self.row_tempfile.read())
- result.extend([
- self.__row_blocks_rec(),
- self.__merged_rec(),
- self.__bitmaps_rec(),
- self.__window2_rec(),
- self.__panes_rec(),
- self.__eof_rec(),
- ])
- return ''.join(result)
-
- def flush_row_data(self):
- if self.row_tempfile is None:
- self.row_tempfile = tempfile.TemporaryFile()
- self.row_tempfile.write(self.__row_blocks_rec())
- for rowx in self.__rows:
- self.__flushed_rows[rowx] = 1
- self.__update_row_visible_levels()
- self.__rows = {}
-
-
diff --git a/tablib/packages/xlwt/__init__.py b/tablib/packages/xlwt/__init__.py deleted file mode 100644 index 6f2a1b5..0000000 --- a/tablib/packages/xlwt/__init__.py +++ /dev/null @@ -1,16 +0,0 @@ -# -*- coding: windows-1252 -*-
-
-__VERSION__ = '0.7.2'
-
-import sys
-if sys.version_info[:2] < (2, 3):
- print >> sys.stderr, "Sorry, xlwt requires Python 2.3 or later"
- sys.exit(1)
-
-from Workbook import Workbook
-from Worksheet import Worksheet
-from Row import Row
-from Column import Column
-from Formatting import Font, Alignment, Borders, Pattern, Protection
-from Style import XFStyle, easyxf
-from ExcelFormula import *
diff --git a/tablib/packages/xlwt/antlr.py b/tablib/packages/xlwt/antlr.py deleted file mode 100644 index 135a50a..0000000 --- a/tablib/packages/xlwt/antlr.py +++ /dev/null @@ -1,2874 +0,0 @@ -## This file is part of PyANTLR. See LICENSE.txt for license
-## details..........Copyright (C) Wolfgang Haefelinger, 2004.
-
-## This file was copied for use with xlwt from the 2.7.7 ANTLR distribution. Yes, it
-## says 2.7.5 below. The 2.7.5 distribution version didn't have a
-## version in it.
-
-## Here is the contents of the ANTLR 2.7.7 LICENSE.txt referred to above.
-
-# SOFTWARE RIGHTS
-#
-# ANTLR 1989-2006 Developed by Terence Parr
-# Partially supported by University of San Francisco & jGuru.com
-#
-# We reserve no legal rights to the ANTLR--it is fully in the
-# public domain. An individual or company may do whatever
-# they wish with source code distributed with ANTLR or the
-# code generated by ANTLR, including the incorporation of
-# ANTLR, or its output, into commerical software.
-#
-# We encourage users to develop software with ANTLR. However,
-# we do ask that credit is given to us for developing
-# ANTLR. By "credit", we mean that if you use ANTLR or
-# incorporate any source code into one of your programs
-# (commercial product, research project, or otherwise) that
-# you acknowledge this fact somewhere in the documentation,
-# research report, etc... If you like ANTLR and have
-# developed a nice tool with the output, please mention that
-# you developed it using ANTLR. In addition, we ask that the
-# headers remain intact in our source code. As long as these
-# guidelines are kept, we expect to continue enhancing this
-# system and expect to make other tools available as they are
-# completed.
-#
-# The primary ANTLR guy:
-#
-# Terence Parr
-# parrt@cs.usfca.edu
-# parrt@antlr.org
-
-## End of contents of the ANTLR 2.7.7 LICENSE.txt ########################
-
-## get sys module
-import sys
-
-version = sys.version.split()[0]
-if version < '2.2.1':
- False = 0
-if version < '2.3':
- True = not False
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### global symbols ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-### ANTLR Standard Tokens
-SKIP = -1
-INVALID_TYPE = 0
-EOF_TYPE = 1
-EOF = 1
-NULL_TREE_LOOKAHEAD = 3
-MIN_USER_TYPE = 4
-
-### ANTLR's EOF Symbol
-EOF_CHAR = ''
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### general functions ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-## Version should be automatically derived from configure.in. For now,
-## we need to bump it ourselfs. Don't remove the <version> tags.
-## <version>
-def version():
- r = {
- 'major' : '2',
- 'minor' : '7',
- 'micro' : '5',
- 'patch' : '' ,
- 'version': '2.7.5'
- }
- return r
-## </version>
-
-def error(fmt,*args):
- if fmt:
- print "error: ", fmt % tuple(args)
-
-def ifelse(cond,_then,_else):
- if cond :
- r = _then
- else:
- r = _else
- return r
-
-def is_string_type(x):
- # return (isinstance(x,str) or isinstance(x,unicode))
- # Simplify; xlwt doesn't support Python < 2.3
- return isinstance(basestring)
-
-def assert_string_type(x):
- assert is_string_type(x)
- pass
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### ANTLR Exceptions ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class ANTLRException(Exception):
-
- def __init__(self, *args):
- Exception.__init__(self, *args)
-
-
-class RecognitionException(ANTLRException):
-
- def __init__(self, *args):
- ANTLRException.__init__(self, *args)
- self.fileName = None
- self.line = -1
- self.column = -1
- if len(args) >= 2:
- self.fileName = args[1]
- if len(args) >= 3:
- self.line = args[2]
- if len(args) >= 4:
- self.column = args[3]
-
- def __str__(self):
- buf = ['']
- if self.fileName:
- buf.append(self.fileName + ":")
- if self.line != -1:
- if not self.fileName:
- buf.append("line ")
- buf.append(str(self.line))
- if self.column != -1:
- buf.append(":" + str(self.column))
- buf.append(":")
- buf.append(" ")
- return str('').join(buf)
-
- __repr__ = __str__
-
-
-class NoViableAltException(RecognitionException):
-
- def __init__(self, *args):
- RecognitionException.__init__(self, *args)
- self.token = None
- self.node = None
- if isinstance(args[0],AST):
- self.node = args[0]
- elif isinstance(args[0],Token):
- self.token = args[0]
- else:
- raise TypeError("NoViableAltException requires Token or AST argument")
-
- def __str__(self):
- if self.token:
- line = self.token.getLine()
- col = self.token.getColumn()
- text = self.token.getText()
- return "unexpected symbol at line %s (column %s): \"%s\"" % (line,col,text)
- if self.node == ASTNULL:
- return "unexpected end of subtree"
- assert self.node
- ### hackish, we assume that an AST contains method getText
- return "unexpected node: %s" % (self.node.getText())
-
- __repr__ = __str__
-
-
-class NoViableAltForCharException(RecognitionException):
-
- def __init__(self, *args):
- self.foundChar = None
- if len(args) == 2:
- self.foundChar = args[0]
- scanner = args[1]
- RecognitionException.__init__(self, "NoViableAlt",
- scanner.getFilename(),
- scanner.getLine(),
- scanner.getColumn())
- elif len(args) == 4:
- self.foundChar = args[0]
- fileName = args[1]
- line = args[2]
- column = args[3]
- RecognitionException.__init__(self, "NoViableAlt",
- fileName, line, column)
- else:
- RecognitionException.__init__(self, "NoViableAlt",
- '', -1, -1)
-
- def __str__(self):
- mesg = "unexpected char: "
- if self.foundChar >= ' ' and self.foundChar <= '~':
- mesg += "'" + self.foundChar + "'"
- elif self.foundChar:
- mesg += "0x" + hex(ord(self.foundChar)).upper()[2:]
- else:
- mesg += "<None>"
- return mesg
-
- __repr__ = __str__
-
-
-class SemanticException(RecognitionException):
-
- def __init__(self, *args):
- RecognitionException.__init__(self, *args)
-
-
-class MismatchedCharException(RecognitionException):
-
- NONE = 0
- CHAR = 1
- NOT_CHAR = 2
- RANGE = 3
- NOT_RANGE = 4
- SET = 5
- NOT_SET = 6
-
- def __init__(self, *args):
- self.args = args
- if len(args) == 5:
- # Expected range / not range
- if args[3]:
- self.mismatchType = MismatchedCharException.NOT_RANGE
- else:
- self.mismatchType = MismatchedCharException.RANGE
- self.foundChar = args[0]
- self.expecting = args[1]
- self.upper = args[2]
- self.scanner = args[4]
- RecognitionException.__init__(self, "Mismatched char range",
- self.scanner.getFilename(),
- self.scanner.getLine(),
- self.scanner.getColumn())
- elif len(args) == 4 and is_string_type(args[1]):
- # Expected char / not char
- if args[2]:
- self.mismatchType = MismatchedCharException.NOT_CHAR
- else:
- self.mismatchType = MismatchedCharException.CHAR
- self.foundChar = args[0]
- self.expecting = args[1]
- self.scanner = args[3]
- RecognitionException.__init__(self, "Mismatched char",
- self.scanner.getFilename(),
- self.scanner.getLine(),
- self.scanner.getColumn())
- elif len(args) == 4 and isinstance(args[1], BitSet):
- # Expected BitSet / not BitSet
- if args[2]:
- self.mismatchType = MismatchedCharException.NOT_SET
- else:
- self.mismatchType = MismatchedCharException.SET
- self.foundChar = args[0]
- self.set = args[1]
- self.scanner = args[3]
- RecognitionException.__init__(self, "Mismatched char set",
- self.scanner.getFilename(),
- self.scanner.getLine(),
- self.scanner.getColumn())
- else:
- self.mismatchType = MismatchedCharException.NONE
- RecognitionException.__init__(self, "Mismatched char")
-
- ## Append a char to the msg buffer. If special,
- # then show escaped version
- #
- def appendCharName(self, sb, c):
- if not c or c == 65535:
- # 65535 = (char) -1 = EOF
- sb.append("'<EOF>'")
- elif c == '\n':
- sb.append("'\\n'")
- elif c == '\r':
- sb.append("'\\r'");
- elif c == '\t':
- sb.append("'\\t'")
- else:
- sb.append('\'' + c + '\'')
-
- ##
- # Returns an error message with line number/column information
- #
- def __str__(self):
- sb = ['']
- sb.append(RecognitionException.__str__(self))
-
- if self.mismatchType == MismatchedCharException.CHAR:
- sb.append("expecting ")
- self.appendCharName(sb, self.expecting)
- sb.append(", found ")
- self.appendCharName(sb, self.foundChar)
- elif self.mismatchType == MismatchedCharException.NOT_CHAR:
- sb.append("expecting anything but '")
- self.appendCharName(sb, self.expecting)
- sb.append("'; got it anyway")
- elif self.mismatchType in [MismatchedCharException.RANGE, MismatchedCharException.NOT_RANGE]:
- sb.append("expecting char ")
- if self.mismatchType == MismatchedCharException.NOT_RANGE:
- sb.append("NOT ")
- sb.append("in range: ")
- appendCharName(sb, self.expecting)
- sb.append("..")
- appendCharName(sb, self.upper)
- sb.append(", found ")
- appendCharName(sb, self.foundChar)
- elif self.mismatchType in [MismatchedCharException.SET, MismatchedCharException.NOT_SET]:
- sb.append("expecting ")
- if self.mismatchType == MismatchedCharException.NOT_SET:
- sb.append("NOT ")
- sb.append("one of (")
- for i in range(len(self.set)):
- self.appendCharName(sb, self.set[i])
- sb.append("), found ")
- self.appendCharName(sb, self.foundChar)
-
- return str().join(sb).strip()
-
- __repr__ = __str__
-
-
-class MismatchedTokenException(RecognitionException):
-
- NONE = 0
- TOKEN = 1
- NOT_TOKEN = 2
- RANGE = 3
- NOT_RANGE = 4
- SET = 5
- NOT_SET = 6
-
- def __init__(self, *args):
- self.args = args
- self.tokenNames = []
- self.token = None
- self.tokenText = ''
- self.node = None
- if len(args) == 6:
- # Expected range / not range
- if args[3]:
- self.mismatchType = MismatchedTokenException.NOT_RANGE
- else:
- self.mismatchType = MismatchedTokenException.RANGE
- self.tokenNames = args[0]
- self.expecting = args[2]
- self.upper = args[3]
- self.fileName = args[5]
-
- elif len(args) == 4 and isinstance(args[2], int):
- # Expected token / not token
- if args[3]:
- self.mismatchType = MismatchedTokenException.NOT_TOKEN
- else:
- self.mismatchType = MismatchedTokenException.TOKEN
- self.tokenNames = args[0]
- self.expecting = args[2]
-
- elif len(args) == 4 and isinstance(args[2], BitSet):
- # Expected BitSet / not BitSet
- if args[3]:
- self.mismatchType = MismatchedTokenException.NOT_SET
- else:
- self.mismatchType = MismatchedTokenException.SET
- self.tokenNames = args[0]
- self.set = args[2]
-
- else:
- self.mismatchType = MismatchedTokenException.NONE
- RecognitionException.__init__(self, "Mismatched Token: expecting any AST node", "<AST>", -1, -1)
-
- if len(args) >= 2:
- if isinstance(args[1],Token):
- self.token = args[1]
- self.tokenText = self.token.getText()
- RecognitionException.__init__(self, "Mismatched Token",
- self.fileName,
- self.token.getLine(),
- self.token.getColumn())
- elif isinstance(args[1],AST):
- self.node = args[1]
- self.tokenText = str(self.node)
- RecognitionException.__init__(self, "Mismatched Token",
- "<AST>",
- self.node.getLine(),
- self.node.getColumn())
- else:
- self.tokenText = "<empty tree>"
- RecognitionException.__init__(self, "Mismatched Token",
- "<AST>", -1, -1)
-
- def appendTokenName(self, sb, tokenType):
- if tokenType == INVALID_TYPE:
- sb.append("<Set of tokens>")
- elif tokenType < 0 or tokenType >= len(self.tokenNames):
- sb.append("<" + str(tokenType) + ">")
- else:
- sb.append(self.tokenNames[tokenType])
-
- ##
- # Returns an error message with line number/column information
- #
- def __str__(self):
- sb = ['']
- sb.append(RecognitionException.__str__(self))
-
- if self.mismatchType == MismatchedTokenException.TOKEN:
- sb.append("expecting ")
- self.appendTokenName(sb, self.expecting)
- sb.append(", found " + self.tokenText)
- elif self.mismatchType == MismatchedTokenException.NOT_TOKEN:
- sb.append("expecting anything but '")
- self.appendTokenName(sb, self.expecting)
- sb.append("'; got it anyway")
- elif self.mismatchType in [MismatchedTokenException.RANGE, MismatchedTokenException.NOT_RANGE]:
- sb.append("expecting token ")
- if self.mismatchType == MismatchedTokenException.NOT_RANGE:
- sb.append("NOT ")
- sb.append("in range: ")
- appendTokenName(sb, self.expecting)
- sb.append("..")
- appendTokenName(sb, self.upper)
- sb.append(", found " + self.tokenText)
- elif self.mismatchType in [MismatchedTokenException.SET, MismatchedTokenException.NOT_SET]:
- sb.append("expecting ")
- if self.mismatchType == MismatchedTokenException.NOT_SET:
- sb.append("NOT ")
- sb.append("one of (")
- for i in range(len(self.set)):
- self.appendTokenName(sb, self.set[i])
- sb.append("), found " + self.tokenText)
-
- return str().join(sb).strip()
-
- __repr__ = __str__
-
-
-class TokenStreamException(ANTLRException):
-
- def __init__(self, *args):
- ANTLRException.__init__(self, *args)
-
-
-# Wraps an Exception in a TokenStreamException
-class TokenStreamIOException(TokenStreamException):
-
- def __init__(self, *args):
- if args and isinstance(args[0], Exception):
- io = args[0]
- TokenStreamException.__init__(self, str(io))
- self.io = io
- else:
- TokenStreamException.__init__(self, *args)
- self.io = self
-
-
-# Wraps a RecognitionException in a TokenStreamException
-class TokenStreamRecognitionException(TokenStreamException):
-
- def __init__(self, *args):
- if args and isinstance(args[0], RecognitionException):
- recog = args[0]
- TokenStreamException.__init__(self, str(recog))
- self.recog = recog
- else:
- raise TypeError("TokenStreamRecognitionException requires RecognitionException argument")
-
- def __str__(self):
- return str(self.recog)
-
- __repr__ = __str__
-
-
-class TokenStreamRetryException(TokenStreamException):
-
- def __init__(self, *args):
- TokenStreamException.__init__(self, *args)
-
-
-class CharStreamException(ANTLRException):
-
- def __init__(self, *args):
- ANTLRException.__init__(self, *args)
-
-
-# Wraps an Exception in a CharStreamException
-class CharStreamIOException(CharStreamException):
-
- def __init__(self, *args):
- if args and isinstance(args[0], Exception):
- io = args[0]
- CharStreamException.__init__(self, str(io))
- self.io = io
- else:
- CharStreamException.__init__(self, *args)
- self.io = self
-
-
-class TryAgain(Exception):
- pass
-
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### Token ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class Token(object):
- SKIP = -1
- INVALID_TYPE = 0
- EOF_TYPE = 1
- EOF = 1
- NULL_TREE_LOOKAHEAD = 3
- MIN_USER_TYPE = 4
-
- def __init__(self,**argv):
- try:
- self.type = argv['type']
- except:
- self.type = INVALID_TYPE
- try:
- self.text = argv['text']
- except:
- self.text = "<no text>"
-
- def isEOF(self):
- return (self.type == EOF_TYPE)
-
- def getColumn(self):
- return 0
-
- def getLine(self):
- return 0
-
- def getFilename(self):
- return None
-
- def setFilename(self,name):
- return self
-
- def getText(self):
- return "<no text>"
-
- def setText(self,text):
- if is_string_type(text):
- pass
- else:
- raise TypeError("Token.setText requires string argument")
- return self
-
- def setColumn(self,column):
- return self
-
- def setLine(self,line):
- return self
-
- def getType(self):
- return self.type
-
- def setType(self,type):
- if isinstance(type,int):
- self.type = type
- else:
- raise TypeError("Token.setType requires integer argument")
- return self
-
- def toString(self):
- ## not optimal
- type_ = self.type
- if type_ == 3:
- tval = 'NULL_TREE_LOOKAHEAD'
- elif type_ == 1:
- tval = 'EOF_TYPE'
- elif type_ == 0:
- tval = 'INVALID_TYPE'
- elif type_ == -1:
- tval = 'SKIP'
- else:
- tval = type_
- return '["%s",<%s>]' % (self.getText(),tval)
-
- __str__ = toString
- __repr__ = toString
-
-### static attribute ..
-Token.badToken = Token( type=INVALID_TYPE, text="<no text>")
-
-if __name__ == "__main__":
- print "testing .."
- T = Token.badToken
- print T
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### CommonToken ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class CommonToken(Token):
-
- def __init__(self,**argv):
- Token.__init__(self,**argv)
- self.line = 0
- self.col = 0
- try:
- self.line = argv['line']
- except:
- pass
- try:
- self.col = argv['col']
- except:
- pass
-
- def getLine(self):
- return self.line
-
- def getText(self):
- return self.text
-
- def getColumn(self):
- return self.col
-
- def setLine(self,line):
- self.line = line
- return self
-
- def setText(self,text):
- self.text = text
- return self
-
- def setColumn(self,col):
- self.col = col
- return self
-
- def toString(self):
- ## not optimal
- type_ = self.type
- if type_ == 3:
- tval = 'NULL_TREE_LOOKAHEAD'
- elif type_ == 1:
- tval = 'EOF_TYPE'
- elif type_ == 0:
- tval = 'INVALID_TYPE'
- elif type_ == -1:
- tval = 'SKIP'
- else:
- tval = type_
- d = {
- 'text' : self.text,
- 'type' : tval,
- 'line' : self.line,
- 'colm' : self.col
- }
-
- fmt = '["%(text)s",<%(type)s>,line=%(line)s,col=%(colm)s]'
- return fmt % d
-
- __str__ = toString
- __repr__ = toString
-
-
-if __name__ == '__main__' :
- T = CommonToken()
- print T
- T = CommonToken(col=15,line=1,text="some text", type=5)
- print T
- T = CommonToken()
- T.setLine(1).setColumn(15).setText("some text").setType(5)
- print T
- print T.getLine()
- print T.getColumn()
- print T.getText()
- print T.getType()
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### CommonHiddenStreamToken ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class CommonHiddenStreamToken(CommonToken):
- def __init__(self,*args):
- CommonToken.__init__(self,*args)
- self.hiddenBefore = None
- self.hiddenAfter = None
-
- def getHiddenAfter(self):
- return self.hiddenAfter
-
- def getHiddenBefore(self):
- return self.hiddenBefore
-
- def setHiddenAfter(self,t):
- self.hiddenAfter = t
-
- def setHiddenBefore(self, t):
- self.hiddenBefore = t
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### Queue ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-## Shall be a circular buffer on tokens ..
-class Queue(object):
-
- def __init__(self):
- self.buffer = [] # empty list
-
- def append(self,item):
- self.buffer.append(item)
-
- def elementAt(self,index):
- return self.buffer[index]
-
- def reset(self):
- self.buffer = []
-
- def removeFirst(self):
- self.buffer.pop(0)
-
- def length(self):
- return len(self.buffer)
-
- def __str__(self):
- return str(self.buffer)
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### InputBuffer ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class InputBuffer(object):
- def __init__(self):
- self.nMarkers = 0
- self.markerOffset = 0
- self.numToConsume = 0
- self.queue = Queue()
-
- def __str__(self):
- return "(%s,%s,%s,%s)" % (
- self.nMarkers,
- self.markerOffset,
- self.numToConsume,
- self.queue)
-
- def __repr__(self):
- return str(self)
-
- def commit(self):
- self.nMarkers -= 1
-
- def consume(self) :
- self.numToConsume += 1
-
- ## probably better to return a list of items
- ## because of unicode. Or return a unicode
- ## string ..
- def getLAChars(self) :
- i = self.markerOffset
- n = self.queue.length()
- s = ''
- while i<n:
- s += self.queue.elementAt(i)
- return s
-
- ## probably better to return a list of items
- ## because of unicode chars
- def getMarkedChars(self) :
- s = ''
- i = 0
- n = self.markerOffset
- while i<n:
- s += self.queue.elementAt(i)
- return s
-
- def isMarked(self) :
- return self.nMarkers != 0
-
- def fill(self,k):
- ### abstract method
- raise NotImplementedError()
-
- def LA(self,k) :
- self.fill(k)
- return self.queue.elementAt(self.markerOffset + k - 1)
-
- def mark(self) :
- self.syncConsume()
- self.nMarkers += 1
- return self.markerOffset
-
- def rewind(self,mark) :
- self.syncConsume()
- self.markerOffset = mark
- self.nMarkers -= 1
-
- def reset(self) :
- self.nMarkers = 0
- self.markerOffset = 0
- self.numToConsume = 0
- self.queue.reset()
-
- def syncConsume(self) :
- while self.numToConsume > 0:
- if self.nMarkers > 0:
- # guess mode -- leave leading characters and bump offset.
- self.markerOffset += 1
- else:
- # normal mode -- remove first character
- self.queue.removeFirst()
- self.numToConsume -= 1
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### CharBuffer ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class CharBuffer(InputBuffer):
- def __init__(self,reader):
- ##assert isinstance(reader,file)
- super(CharBuffer,self).__init__()
- ## a reader is supposed to be anything that has
- ## a method 'read(int)'.
- self.input = reader
-
- def __str__(self):
- base = super(CharBuffer,self).__str__()
- return "CharBuffer{%s,%s" % (base,str(input))
-
- def fill(self,amount):
- try:
- self.syncConsume()
- while self.queue.length() < (amount + self.markerOffset) :
- ## retrieve just one char - what happend at end
- ## of input?
- c = self.input.read(1)
- ### python's behaviour is to return the empty string on
- ### EOF, ie. no exception whatsoever is thrown. An empty
- ### python string has the nice feature that it is of
- ### type 'str' and "not ''" would return true. Contrary,
- ### one can't do this: '' in 'abc'. This should return
- ### false, but all we get is then a TypeError as an
- ### empty string is not a character.
-
- ### Let's assure then that we have either seen a
- ### character or an empty string (EOF).
- assert len(c) == 0 or len(c) == 1
-
- ### And it shall be of type string (ASCII or UNICODE).
- assert is_string_type(c)
-
- ### Just append EOF char to buffer. Note that buffer may
- ### contain then just more than one EOF char ..
-
- ### use unicode chars instead of ASCII ..
- self.queue.append(c)
- except Exception,e:
- raise CharStreamIOException(e)
- ##except: # (mk) Cannot happen ...
- ##error ("unexpected exception caught ..")
- ##assert 0
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### LexerSharedInputState ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class LexerSharedInputState(object):
- def __init__(self,ibuf):
- assert isinstance(ibuf,InputBuffer)
- self.input = ibuf
- self.column = 1
- self.line = 1
- self.tokenStartColumn = 1
- self.tokenStartLine = 1
- self.guessing = 0
- self.filename = None
-
- def reset(self):
- self.column = 1
- self.line = 1
- self.tokenStartColumn = 1
- self.tokenStartLine = 1
- self.guessing = 0
- self.filename = None
- self.input.reset()
-
- def LA(self,k):
- return self.input.LA(k)
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### TokenStream ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class TokenStream(object):
- def nextToken(self):
- pass
-
- def __iter__(self):
- return TokenStreamIterator(self)
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### TokenStreamIterator ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class TokenStreamIterator(object):
- def __init__(self,inst):
- if isinstance(inst,TokenStream):
- self.inst = inst
- return
- raise TypeError("TokenStreamIterator requires TokenStream object")
-
- def next(self):
- assert self.inst
- item = self.inst.nextToken()
- if not item or item.isEOF():
- raise StopIteration()
- return item
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### TokenStreamSelector ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class TokenStreamSelector(TokenStream):
-
- def __init__(self):
- self._input = None
- self._stmap = {}
- self._stack = []
-
- def addInputStream(self,stream,key):
- self._stmap[key] = stream
-
- def getCurrentStream(self):
- return self._input
-
- def getStream(self,sname):
- try:
- stream = self._stmap[sname]
- except:
- raise ValueError("TokenStream " + sname + " not found");
- return stream;
-
- def nextToken(self):
- while 1:
- try:
- return self._input.nextToken()
- except TokenStreamRetryException,r:
- ### just retry "forever"
- pass
-
- def pop(self):
- stream = self._stack.pop();
- self.select(stream);
- return stream;
-
- def push(self,arg):
- self._stack.append(self._input);
- self.select(arg)
-
- def retry(self):
- raise TokenStreamRetryException()
-
- def select(self,arg):
- if isinstance(arg,TokenStream):
- self._input = arg
- return
- if is_string_type(arg):
- self._input = self.getStream(arg)
- return
- raise TypeError("TokenStreamSelector.select requires " +
- "TokenStream or string argument")
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### TokenStreamBasicFilter ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class TokenStreamBasicFilter(TokenStream):
-
- def __init__(self,input):
-
- self.input = input;
- self.discardMask = BitSet()
-
- def discard(self,arg):
- if isinstance(arg,int):
- self.discardMask.add(arg)
- return
- if isinstance(arg,BitSet):
- self.discardMark = arg
- return
- raise TypeError("TokenStreamBasicFilter.discard requires" +
- "integer or BitSet argument")
-
- def nextToken(self):
- tok = self.input.nextToken()
- while tok and self.discardMask.member(tok.getType()):
- tok = self.input.nextToken()
- return tok
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### TokenStreamHiddenTokenFilter ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class TokenStreamHiddenTokenFilter(TokenStreamBasicFilter):
-
- def __init__(self,input):
- TokenStreamBasicFilter.__init__(self,input)
- self.hideMask = BitSet()
- self.nextMonitoredToken = None
- self.lastHiddenToken = None
- self.firstHidden = None
-
- def consume(self):
- self.nextMonitoredToken = self.input.nextToken()
-
- def consumeFirst(self):
- self.consume()
-
- p = None;
- while self.hideMask.member(self.LA(1).getType()) or \
- self.discardMask.member(self.LA(1).getType()):
- if self.hideMask.member(self.LA(1).getType()):
- if not p:
- p = self.LA(1)
- else:
- p.setHiddenAfter(self.LA(1))
- self.LA(1).setHiddenBefore(p)
- p = self.LA(1)
- self.lastHiddenToken = p
- if not self.firstHidden:
- self.firstHidden = p
- self.consume()
-
- def getDiscardMask(self):
- return self.discardMask
-
- def getHiddenAfter(self,t):
- return t.getHiddenAfter()
-
- def getHiddenBefore(self,t):
- return t.getHiddenBefore()
-
- def getHideMask(self):
- return self.hideMask
-
- def getInitialHiddenToken(self):
- return self.firstHidden
-
- def hide(self,m):
- if isinstance(m,int):
- self.hideMask.add(m)
- return
- if isinstance(m.BitMask):
- self.hideMask = m
- return
-
- def LA(self,i):
- return self.nextMonitoredToken
-
- def nextToken(self):
- if not self.LA(1):
- self.consumeFirst()
-
- monitored = self.LA(1)
-
- monitored.setHiddenBefore(self.lastHiddenToken)
- self.lastHiddenToken = None
-
- self.consume()
- p = monitored
-
- while self.hideMask.member(self.LA(1).getType()) or \
- self.discardMask.member(self.LA(1).getType()):
- if self.hideMask.member(self.LA(1).getType()):
- p.setHiddenAfter(self.LA(1))
- if p != monitored:
- self.LA(1).setHiddenBefore(p)
- p = self.lastHiddenToken = self.LA(1)
- self.consume()
- return monitored
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### StringBuffer ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class StringBuffer:
- def __init__(self,string=None):
- if string:
- self.text = list(string)
- else:
- self.text = []
-
- def setLength(self,sz):
- if not sz :
- self.text = []
- return
- assert sz>0
- if sz >= self.length():
- return
- ### just reset to empty buffer
- self.text = self.text[0:sz]
-
- def length(self):
- return len(self.text)
-
- def append(self,c):
- self.text.append(c)
-
- ### return buffer as string. Arg 'a' is used as index
- ## into the buffer and 2nd argument shall be the length.
- ## If 2nd args is absent, we return chars till end of
- ## buffer starting with 'a'.
- def getString(self,a=None,length=None):
- if not a :
- a = 0
- assert a>=0
- if a>= len(self.text) :
- return ""
-
- if not length:
- ## no second argument
- L = self.text[a:]
- else:
- assert (a+length) <= len(self.text)
- b = a + length
- L = self.text[a:b]
- s = ""
- for x in L : s += x
- return s
-
- toString = getString ## alias
-
- def __str__(self):
- return str(self.text)
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### Reader ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-## When reading Japanese chars, it happens that a stream returns a
-## 'char' of length 2. This looks like a bug in the appropriate
-## codecs - but I'm rather unsure about this. Anyway, if this is
-## the case, I'm going to split this string into a list of chars
-## and put them on hold, ie. on a buffer. Next time when called
-## we read from buffer until buffer is empty.
-## wh: nov, 25th -> problem does not appear in Python 2.4.0.c1.
-
-class Reader(object):
- def __init__(self,stream):
- self.cin = stream
- self.buf = []
-
- def read(self,num):
- assert num==1
-
- if len(self.buf):
- return self.buf.pop()
-
- ## Read a char - this may return a string.
- ## Is this a bug in codecs/Python?
- c = self.cin.read(1)
-
- if not c or len(c)==1:
- return c
-
- L = list(c)
- L.reverse()
- for x in L:
- self.buf.append(x)
-
- ## read one char ..
- return self.read(1)
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### CharScanner ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class CharScanner(TokenStream):
- ## class members
- NO_CHAR = 0
- EOF_CHAR = '' ### EOF shall be the empty string.
-
- def __init__(self, *argv, **kwargs):
- super(CharScanner, self).__init__()
- self.saveConsumedInput = True
- self.tokenClass = None
- self.caseSensitive = True
- self.caseSensitiveLiterals = True
- self.literals = None
- self.tabsize = 8
- self._returnToken = None
- self.commitToPath = False
- self.traceDepth = 0
- self.text = StringBuffer()
- self.hashString = hash(self)
- self.setTokenObjectClass(CommonToken)
- self.setInput(*argv)
-
- def __iter__(self):
- return CharScannerIterator(self)
-
- def setInput(self,*argv):
- ## case 1:
- ## if there's no arg we default to read from
- ## standard input
- if not argv:
- import sys
- self.setInput(sys.stdin)
- return
-
- ## get 1st argument
- arg1 = argv[0]
-
- ## case 2:
- ## if arg1 is a string, we assume it's a file name
- ## and open a stream using 2nd argument as open
- ## mode. If there's no 2nd argument we fall back to
- ## mode '+rb'.
- if is_string_type(arg1):
- f = open(arg1,"rb")
- self.setInput(f)
- self.setFilename(arg1)
- return
-
- ## case 3:
- ## if arg1 is a file we wrap it by a char buffer (
- ## some additional checks?? No, can't do this in
- ## general).
- if isinstance(arg1,file):
- self.setInput(CharBuffer(arg1))
- return
-
- ## case 4:
- ## if arg1 is of type SharedLexerInputState we use
- ## argument as is.
- if isinstance(arg1,LexerSharedInputState):
- self.inputState = arg1
- return
-
- ## case 5:
- ## check whether argument type is of type input
- ## buffer. If so create a SharedLexerInputState and
- ## go ahead.
- if isinstance(arg1,InputBuffer):
- self.setInput(LexerSharedInputState(arg1))
- return
-
- ## case 6:
- ## check whether argument type has a method read(int)
- ## If so create CharBuffer ...
- try:
- if arg1.read:
- rd = Reader(arg1)
- cb = CharBuffer(rd)
- ss = LexerSharedInputState(cb)
- self.inputState = ss
- return
- except:
- pass
-
- ## case 7:
- ## raise wrong argument exception
- raise TypeError(argv)
-
- def setTabSize(self,size) :
- self.tabsize = size
-
- def getTabSize(self) :
- return self.tabsize
-
- def setCaseSensitive(self,t) :
- self.caseSensitive = t
-
- def setCommitToPath(self,commit) :
- self.commitToPath = commit
-
- def setFilename(self,f) :
- self.inputState.filename = f
-
- def setLine(self,line) :
- self.inputState.line = line
-
- def setText(self,s) :
- self.resetText()
- self.text.append(s)
-
- def getCaseSensitive(self) :
- return self.caseSensitive
-
- def getCaseSensitiveLiterals(self) :
- return self.caseSensitiveLiterals
-
- def getColumn(self) :
- return self.inputState.column
-
- def setColumn(self,c) :
- self.inputState.column = c
-
- def getCommitToPath(self) :
- return self.commitToPath
-
- def getFilename(self) :
- return self.inputState.filename
-
- def getInputBuffer(self) :
- return self.inputState.input
-
- def getInputState(self) :
- return self.inputState
-
- def setInputState(self,state) :
- assert isinstance(state,LexerSharedInputState)
- self.inputState = state
-
- def getLine(self) :
- return self.inputState.line
-
- def getText(self) :
- return str(self.text)
-
- def getTokenObject(self) :
- return self._returnToken
-
- def LA(self,i) :
- c = self.inputState.input.LA(i)
- if not self.caseSensitive:
- ### E0006
- c = c.__class__.lower(c)
- return c
-
- def makeToken(self,type) :
- try:
- ## dynamically load a class
- assert self.tokenClass
- tok = self.tokenClass()
- tok.setType(type)
- tok.setColumn(self.inputState.tokenStartColumn)
- tok.setLine(self.inputState.tokenStartLine)
- return tok
- except:
- self.panic("unable to create new token")
- return Token.badToken
-
- def mark(self) :
- return self.inputState.input.mark()
-
- def _match_bitset(self,b) :
- if b.member(self.LA(1)):
- self.consume()
- else:
- raise MismatchedCharException(self.LA(1), b, False, self)
-
- def _match_string(self,s) :
- for c in s:
- if self.LA(1) == c:
- self.consume()
- else:
- raise MismatchedCharException(self.LA(1), c, False, self)
-
- def match(self,item):
- if is_string_type(item):
- return self._match_string(item)
- else:
- return self._match_bitset(item)
-
- def matchNot(self,c) :
- if self.LA(1) != c:
- self.consume()
- else:
- raise MismatchedCharException(self.LA(1), c, True, self)
-
- def matchRange(self,c1,c2) :
- if self.LA(1) < c1 or self.LA(1) > c2 :
- raise MismatchedCharException(self.LA(1), c1, c2, False, self)
- else:
- self.consume()
-
- def newline(self) :
- self.inputState.line += 1
- self.inputState.column = 1
-
- def tab(self) :
- c = self.getColumn()
- nc = ( ((c-1)/self.tabsize) + 1) * self.tabsize + 1
- self.setColumn(nc)
-
- def panic(self,s='') :
- print "CharScanner: panic: " + s
- sys.exit(1)
-
- def reportError(self,ex) :
- print ex
-
- def reportError(self,s) :
- if not self.getFilename():
- print "error: " + str(s)
- else:
- print self.getFilename() + ": error: " + str(s)
-
- def reportWarning(self,s) :
- if not self.getFilename():
- print "warning: " + str(s)
- else:
- print self.getFilename() + ": warning: " + str(s)
-
- def resetText(self) :
- self.text.setLength(0)
- self.inputState.tokenStartColumn = self.inputState.column
- self.inputState.tokenStartLine = self.inputState.line
-
- def rewind(self,pos) :
- self.inputState.input.rewind(pos)
-
- def setTokenObjectClass(self,cl):
- self.tokenClass = cl
-
- def testForLiteral(self,token):
- if not token:
- return
- assert isinstance(token,Token)
-
- _type = token.getType()
-
- ## special tokens can't be literals
- if _type in [SKIP,INVALID_TYPE,EOF_TYPE,NULL_TREE_LOOKAHEAD] :
- return
-
- _text = token.getText()
- if not _text:
- return
-
- assert is_string_type(_text)
- _type = self.testLiteralsTable(_text,_type)
- token.setType(_type)
- return _type
-
- def testLiteralsTable(self,*args):
- if is_string_type(args[0]):
- s = args[0]
- i = args[1]
- else:
- s = self.text.getString()
- i = args[0]
-
- ## check whether integer has been given
- if not isinstance(i,int):
- assert isinstance(i,int)
-
- ## check whether we have a dict
- assert isinstance(self.literals,dict)
- try:
- ## E0010
- if not self.caseSensitiveLiterals:
- s = s.__class__.lower(s)
- i = self.literals[s]
- except:
- pass
- return i
-
- def toLower(self,c):
- return c.__class__.lower()
-
- def traceIndent(self):
- print ' ' * self.traceDepth
-
- def traceIn(self,rname):
- self.traceDepth += 1
- self.traceIndent()
- print "> lexer %s c== %s" % (rname,self.LA(1))
-
- def traceOut(self,rname):
- self.traceIndent()
- print "< lexer %s c== %s" % (rname,self.LA(1))
- self.traceDepth -= 1
-
- def uponEOF(self):
- pass
-
- def append(self,c):
- if self.saveConsumedInput :
- self.text.append(c)
-
- def commit(self):
- self.inputState.input.commit()
-
- def consume(self):
- if not self.inputState.guessing:
- c = self.LA(1)
- if self.caseSensitive:
- self.append(c)
- else:
- # use input.LA(), not LA(), to get original case
- # CharScanner.LA() would toLower it.
- c = self.inputState.input.LA(1)
- self.append(c)
-
- if c and c in "\t":
- self.tab()
- else:
- self.inputState.column += 1
- self.inputState.input.consume()
-
- ## Consume chars until one matches the given char
- def consumeUntil_char(self,c):
- while self.LA(1) != EOF_CHAR and self.LA(1) != c:
- self.consume()
-
- ## Consume chars until one matches the given set
- def consumeUntil_bitset(self,bitset):
- while self.LA(1) != EOF_CHAR and not self.set.member(self.LA(1)):
- self.consume()
-
- ### If symbol seen is EOF then generate and set token, otherwise
- ### throw exception.
- def default(self,la1):
- if not la1 :
- self.uponEOF()
- self._returnToken = self.makeToken(EOF_TYPE)
- else:
- self.raise_NoViableAlt(la1)
-
- def filterdefault(self,la1,*args):
- if not la1:
- self.uponEOF()
- self._returnToken = self.makeToken(EOF_TYPE)
- return
-
- if not args:
- self.consume()
- raise TryAgain()
- else:
- ### apply filter object
- self.commit();
- try:
- func=args[0]
- args=args[1:]
- apply(func,args)
- except RecognitionException, e:
- ## catastrophic failure
- self.reportError(e);
- self.consume();
- raise TryAgain()
-
- def raise_NoViableAlt(self,la1=None):
- if not la1: la1 = self.LA(1)
- fname = self.getFilename()
- line = self.getLine()
- col = self.getColumn()
- raise NoViableAltForCharException(la1,fname,line,col)
-
- def set_return_token(self,_create,_token,_ttype,_offset):
- if _create and not _token and (not _ttype == SKIP):
- string = self.text.getString(_offset)
- _token = self.makeToken(_ttype)
- _token.setText(string)
- self._returnToken = _token
- return _token
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### CharScannerIterator ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class CharScannerIterator:
-
- def __init__(self,inst):
- if isinstance(inst,CharScanner):
- self.inst = inst
- return
- raise TypeError("CharScannerIterator requires CharScanner object")
-
- def next(self):
- assert self.inst
- item = self.inst.nextToken()
- if not item or item.isEOF():
- raise StopIteration()
- return item
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### BitSet ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-### I'm assuming here that a long is 64bits. It appears however, that
-### a long is of any size. That means we can use a single long as the
-### bitset (!), ie. Python would do almost all the work (TBD).
-
-class BitSet(object):
- BITS = 64
- NIBBLE = 4
- LOG_BITS = 6
- MOD_MASK = BITS -1
-
- def __init__(self,data=None):
- if not data:
- BitSet.__init__(self,[long(0)])
- return
- if isinstance(data,int):
- BitSet.__init__(self,[long(data)])
- return
- if isinstance(data,long):
- BitSet.__init__(self,[data])
- return
- if not isinstance(data,list):
- raise TypeError("BitSet requires integer, long, or " +
- "list argument")
- for x in data:
- if not isinstance(x,long):
- raise TypeError(self,"List argument item is " +
- "not a long: %s" % (x))
- self.data = data
-
- def __str__(self):
- bits = len(self.data) * BitSet.BITS
- s = ""
- for i in xrange(0,bits):
- if self.at(i):
- s += "1"
- else:
- s += "o"
- if not ((i+1) % 10):
- s += '|%s|' % (i+1)
- return s
-
- def __repr__(self):
- return str(self)
-
- def member(self,item):
- if not item:
- return False
-
- if isinstance(item,int):
- return self.at(item)
-
- if not is_string_type(item):
- raise TypeError(self,"char or unichar expected: %s" % (item))
-
- ## char is a (unicode) string with at most lenght 1, ie.
- ## a char.
-
- if len(item) != 1:
- raise TypeError(self,"char expected: %s" % (item))
-
- ### handle ASCII/UNICODE char
- num = ord(item)
-
- ### check whether position num is in bitset
- return self.at(num)
-
- def wordNumber(self,bit):
- return bit >> BitSet.LOG_BITS
-
- def bitMask(self,bit):
- pos = bit & BitSet.MOD_MASK ## bit mod BITS
- return (1L << pos)
-
- def set(self,bit,on=True):
- # grow bitset as required (use with care!)
- i = self.wordNumber(bit)
- mask = self.bitMask(bit)
- if i>=len(self.data):
- d = i - len(self.data) + 1
- for x in xrange(0,d):
- self.data.append(0L)
- assert len(self.data) == i+1
- if on:
- self.data[i] |= mask
- else:
- self.data[i] &= (~mask)
-
- ### make add an alias for set
- add = set
-
- def off(self,bit,off=True):
- self.set(bit,not off)
-
- def at(self,bit):
- i = self.wordNumber(bit)
- v = self.data[i]
- m = self.bitMask(bit)
- return v & m
-
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### some further funcs ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-def illegalarg_ex(func):
- raise ValueError(
- "%s is only valid if parser is built for debugging" %
- (func.func_name))
-
-def runtime_ex(func):
- raise RuntimeException(
- "%s is only valid if parser is built for debugging" %
- (func.func_name))
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### TokenBuffer ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class TokenBuffer(object):
- def __init__(self,stream):
- self.input = stream
- self.nMarkers = 0
- self.markerOffset = 0
- self.numToConsume = 0
- self.queue = Queue()
-
- def reset(self) :
- self.nMarkers = 0
- self.markerOffset = 0
- self.numToConsume = 0
- self.queue.reset()
-
- def consume(self) :
- self.numToConsume += 1
-
- def fill(self, amount):
- self.syncConsume()
- while self.queue.length() < (amount + self.markerOffset):
- self.queue.append(self.input.nextToken())
-
- def getInput(self):
- return self.input
-
- def LA(self,k) :
- self.fill(k)
- return self.queue.elementAt(self.markerOffset + k - 1).type
-
- def LT(self,k) :
- self.fill(k)
- return self.queue.elementAt(self.markerOffset + k - 1)
-
- def mark(self) :
- self.syncConsume()
- self.nMarkers += 1
- return self.markerOffset
-
- def rewind(self,mark) :
- self.syncConsume()
- self.markerOffset = mark
- self.nMarkers -= 1
-
- def syncConsume(self) :
- while self.numToConsume > 0:
- if self.nMarkers > 0:
- # guess mode -- leave leading characters and bump offset.
- self.markerOffset += 1
- else:
- # normal mode -- remove first character
- self.queue.removeFirst()
- self.numToConsume -= 1
-
- def __str__(self):
- return "(%s,%s,%s,%s,%s)" % (
- self.input,
- self.nMarkers,
- self.markerOffset,
- self.numToConsume,
- self.queue)
-
- def __repr__(self):
- return str(self)
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### ParserSharedInputState ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class ParserSharedInputState(object):
-
- def __init__(self):
- self.input = None
- self.reset()
-
- def reset(self):
- self.guessing = 0
- self.filename = None
- if self.input:
- self.input.reset()
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### Parser ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class Parser(object):
-
- def __init__(self, *args, **kwargs):
- self.tokenNames = None
- self.returnAST = None
- self.astFactory = None
- self.tokenTypeToASTClassMap = {}
- self.ignoreInvalidDebugCalls = False
- self.traceDepth = 0
- if not args:
- self.inputState = ParserSharedInputState()
- return
- arg0 = args[0]
- assert isinstance(arg0,ParserSharedInputState)
- self.inputState = arg0
- return
-
- def getTokenTypeToASTClassMap(self):
- return self.tokenTypeToASTClassMap
-
-
- def addMessageListener(self, l):
- if not self.ignoreInvalidDebugCalls:
- illegalarg_ex(addMessageListener)
-
- def addParserListener(self,l) :
- if (not self.ignoreInvalidDebugCalls) :
- illegalarg_ex(addParserListener)
-
- def addParserMatchListener(self, l) :
- if (not self.ignoreInvalidDebugCalls) :
- illegalarg_ex(addParserMatchListener)
-
- def addParserTokenListener(self, l) :
- if (not self.ignoreInvalidDebugCalls):
- illegalarg_ex(addParserTokenListener)
-
- def addSemanticPredicateListener(self, l) :
- if (not self.ignoreInvalidDebugCalls):
- illegalarg_ex(addSemanticPredicateListener)
-
- def addSyntacticPredicateListener(self, l) :
- if (not self.ignoreInvalidDebugCalls):
- illegalarg_ex(addSyntacticPredicateListener)
-
- def addTraceListener(self, l) :
- if (not self.ignoreInvalidDebugCalls):
- illegalarg_ex(addTraceListener)
-
- def consume(self):
- raise NotImplementedError()
-
- def _consumeUntil_type(self,tokenType):
- while self.LA(1) != EOF_TYPE and self.LA(1) != tokenType:
- self.consume()
-
- def _consumeUntil_bitset(self, set):
- while self.LA(1) != EOF_TYPE and not set.member(self.LA(1)):
- self.consume()
-
- def consumeUntil(self,arg):
- if isinstance(arg,int):
- self._consumeUntil_type(arg)
- else:
- self._consumeUntil_bitset(arg)
-
- def defaultDebuggingSetup(self):
- pass
-
- def getAST(self) :
- return self.returnAST
-
- def getASTFactory(self) :
- return self.astFactory
-
- def getFilename(self) :
- return self.inputState.filename
-
- def getInputState(self) :
- return self.inputState
-
- def setInputState(self, state) :
- self.inputState = state
-
- def getTokenName(self,num) :
- return self.tokenNames[num]
-
- def getTokenNames(self) :
- return self.tokenNames
-
- def isDebugMode(self) :
- return self.false
-
- def LA(self, i):
- raise NotImplementedError()
-
- def LT(self, i):
- raise NotImplementedError()
-
- def mark(self):
- return self.inputState.input.mark()
-
- def _match_int(self,t):
- if (self.LA(1) != t):
- raise MismatchedTokenException(
- self.tokenNames, self.LT(1), t, False, self.getFilename())
- else:
- self.consume()
-
- def _match_set(self, b):
- if (not b.member(self.LA(1))):
- raise MismatchedTokenException(
- self.tokenNames,self.LT(1), b, False, self.getFilename())
- else:
- self.consume()
-
- def match(self,set) :
- if isinstance(set,int):
- self._match_int(set)
- return
- if isinstance(set,BitSet):
- self._match_set(set)
- return
- raise TypeError("Parser.match requires integer ot BitSet argument")
-
- def matchNot(self,t):
- if self.LA(1) == t:
- raise MismatchedTokenException(
- tokenNames, self.LT(1), t, True, self.getFilename())
- else:
- self.consume()
-
- def removeMessageListener(self, l) :
- if (not self.ignoreInvalidDebugCalls):
- runtime_ex(removeMessageListener)
-
- def removeParserListener(self, l) :
- if (not self.ignoreInvalidDebugCalls):
- runtime_ex(removeParserListener)
-
- def removeParserMatchListener(self, l) :
- if (not self.ignoreInvalidDebugCalls):
- runtime_ex(removeParserMatchListener)
-
- def removeParserTokenListener(self, l) :
- if (not self.ignoreInvalidDebugCalls):
- runtime_ex(removeParserTokenListener)
-
- def removeSemanticPredicateListener(self, l) :
- if (not self.ignoreInvalidDebugCalls):
- runtime_ex(removeSemanticPredicateListener)
-
- def removeSyntacticPredicateListener(self, l) :
- if (not self.ignoreInvalidDebugCalls):
- runtime_ex(removeSyntacticPredicateListener)
-
- def removeTraceListener(self, l) :
- if (not self.ignoreInvalidDebugCalls):
- runtime_ex(removeTraceListener)
-
- def reportError(self,x) :
- fmt = "syntax error:"
- f = self.getFilename()
- if f:
- fmt = ("%s:" % f) + fmt
- if isinstance(x,Token):
- line = x.getColumn()
- col = x.getLine()
- text = x.getText()
- fmt = fmt + 'unexpected symbol at line %s (column %s) : "%s"'
- print >>sys.stderr, fmt % (line,col,text)
- else:
- print >>sys.stderr, fmt,str(x)
-
- def reportWarning(self,s):
- f = self.getFilename()
- if f:
- print "%s:warning: %s" % (f,str(x))
- else:
- print "warning: %s" % (str(x))
-
- def rewind(self, pos) :
- self.inputState.input.rewind(pos)
-
- def setASTFactory(self, f) :
- self.astFactory = f
-
- def setASTNodeClass(self, cl) :
- self.astFactory.setASTNodeType(cl)
-
- def setASTNodeType(self, nodeType) :
- self.setASTNodeClass(nodeType)
-
- def setDebugMode(self, debugMode) :
- if (not self.ignoreInvalidDebugCalls):
- runtime_ex(setDebugMode)
-
- def setFilename(self, f) :
- self.inputState.filename = f
-
- def setIgnoreInvalidDebugCalls(self, value) :
- self.ignoreInvalidDebugCalls = value
-
- def setTokenBuffer(self, t) :
- self.inputState.input = t
-
- def traceIndent(self):
- print " " * self.traceDepth
-
- def traceIn(self,rname):
- self.traceDepth += 1
- self.trace("> ", rname)
-
- def traceOut(self,rname):
- self.trace("< ", rname)
- self.traceDepth -= 1
-
- ### wh: moved from ASTFactory to Parser
- def addASTChild(self,currentAST, child):
- if not child:
- return
- if not currentAST.root:
- currentAST.root = child
- elif not currentAST.child:
- currentAST.root.setFirstChild(child)
- else:
- currentAST.child.setNextSibling(child)
- currentAST.child = child
- currentAST.advanceChildToEnd()
-
- ### wh: moved from ASTFactory to Parser
- def makeASTRoot(self,currentAST,root) :
- if root:
- ### Add the current root as a child of new root
- root.addChild(currentAST.root)
- ### The new current child is the last sibling of the old root
- currentAST.child = currentAST.root
- currentAST.advanceChildToEnd()
- ### Set the new root
- currentAST.root = root
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### LLkParser ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class LLkParser(Parser):
-
- def __init__(self, *args, **kwargs):
- try:
- arg1 = args[0]
- except:
- arg1 = 1
-
- if isinstance(arg1,int):
- super(LLkParser,self).__init__()
- self.k = arg1
- return
-
- if isinstance(arg1,ParserSharedInputState):
- super(LLkParser,self).__init__(arg1)
- self.set_k(1,*args)
- return
-
- if isinstance(arg1,TokenBuffer):
- super(LLkParser,self).__init__()
- self.setTokenBuffer(arg1)
- self.set_k(1,*args)
- return
-
- if isinstance(arg1,TokenStream):
- super(LLkParser,self).__init__()
- tokenBuf = TokenBuffer(arg1)
- self.setTokenBuffer(tokenBuf)
- self.set_k(1,*args)
- return
-
- ### unknown argument
- raise TypeError("LLkParser requires integer, " +
- "ParserSharedInputStream or TokenStream argument")
-
- def consume(self):
- self.inputState.input.consume()
-
- def LA(self,i):
- return self.inputState.input.LA(i)
-
- def LT(self,i):
- return self.inputState.input.LT(i)
-
- def set_k(self,index,*args):
- try:
- self.k = args[index]
- except:
- self.k = 1
-
- def trace(self,ee,rname):
- print type(self)
- self.traceIndent()
- guess = ""
- if self.inputState.guessing > 0:
- guess = " [guessing]"
- print(ee + rname + guess)
- for i in xrange(1,self.k+1):
- if i != 1:
- print(", ")
- if self.LT(i) :
- v = self.LT(i).getText()
- else:
- v = "null"
- print "LA(%s) == %s" % (i,v)
- print("\n")
-
- def traceIn(self,rname):
- self.traceDepth += 1;
- self.trace("> ", rname);
-
- def traceOut(self,rname):
- self.trace("< ", rname);
- self.traceDepth -= 1;
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### TreeParserSharedInputState ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class TreeParserSharedInputState(object):
- def __init__(self):
- self.guessing = 0
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### TreeParser ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class TreeParser(object):
-
- def __init__(self, *args, **kwargs):
- self.inputState = TreeParserSharedInputState()
- self._retTree = None
- self.tokenNames = []
- self.returnAST = None
- self.astFactory = ASTFactory()
- self.traceDepth = 0
-
- def getAST(self):
- return self.returnAST
-
- def getASTFactory(self):
- return self.astFactory
-
- def getTokenName(self,num) :
- return self.tokenNames[num]
-
- def getTokenNames(self):
- return self.tokenNames
-
- def match(self,t,set) :
- assert isinstance(set,int) or isinstance(set,BitSet)
- if not t or t == ASTNULL:
- raise MismatchedTokenException(self.getTokenNames(), t,set, False)
-
- if isinstance(set,int) and t.getType() != set:
- raise MismatchedTokenException(self.getTokenNames(), t,set, False)
-
- if isinstance(set,BitSet) and not set.member(t.getType):
- raise MismatchedTokenException(self.getTokenNames(), t,set, False)
-
- def matchNot(self,t, ttype) :
- if not t or (t == ASTNULL) or (t.getType() == ttype):
- raise MismatchedTokenException(getTokenNames(), t, ttype, True)
-
- def reportError(self,ex):
- print >>sys.stderr,"error:",ex
-
- def reportWarning(self, s):
- print "warning:",s
-
- def setASTFactory(self,f):
- self.astFactory = f
-
- def setASTNodeType(self,nodeType):
- self.setASTNodeClass(nodeType)
-
- def setASTNodeClass(self,nodeType):
- self.astFactory.setASTNodeType(nodeType)
-
- def traceIndent(self):
- print " " * self.traceDepth
-
- def traceIn(self,rname,t):
- self.traceDepth += 1
- self.traceIndent()
- print("> " + rname + "(" +
- ifelse(t,str(t),"null") + ")" +
- ifelse(self.inputState.guessing>0,"[guessing]",""))
-
- def traceOut(self,rname,t):
- self.traceIndent()
- print("< " + rname + "(" +
- ifelse(t,str(t),"null") + ")" +
- ifelse(self.inputState.guessing>0,"[guessing]",""))
- self.traceDepth -= 1
-
- ### wh: moved from ASTFactory to TreeParser
- def addASTChild(self,currentAST, child):
- if not child:
- return
- if not currentAST.root:
- currentAST.root = child
- elif not currentAST.child:
- currentAST.root.setFirstChild(child)
- else:
- currentAST.child.setNextSibling(child)
- currentAST.child = child
- currentAST.advanceChildToEnd()
-
- ### wh: moved from ASTFactory to TreeParser
- def makeASTRoot(self,currentAST,root):
- if root:
- ### Add the current root as a child of new root
- root.addChild(currentAST.root)
- ### The new current child is the last sibling of the old root
- currentAST.child = currentAST.root
- currentAST.advanceChildToEnd()
- ### Set the new root
- currentAST.root = root
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### funcs to work on trees ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-def rightmost(ast):
- if ast:
- while(ast.right):
- ast = ast.right
- return ast
-
-def cmptree(s,t,partial):
- while(s and t):
- ### as a quick optimization, check roots first.
- if not s.equals(t):
- return False
-
- ### if roots match, do full list match test on children.
- if not cmptree(s.getFirstChild(),t.getFirstChild(),partial):
- return False
-
- s = s.getNextSibling()
- t = t.getNextSibling()
-
- r = ifelse(partial,not t,not s and not t)
- return r
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### AST ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class AST(object):
- def __init__(self):
- pass
-
- def addChild(self, c):
- pass
-
- def equals(self, t):
- return False
-
- def equalsList(self, t):
- return False
-
- def equalsListPartial(self, t):
- return False
-
- def equalsTree(self, t):
- return False
-
- def equalsTreePartial(self, t):
- return False
-
- def findAll(self, tree):
- return None
-
- def findAllPartial(self, subtree):
- return None
-
- def getFirstChild(self):
- return self
-
- def getNextSibling(self):
- return self
-
- def getText(self):
- return ""
-
- def getType(self):
- return INVALID_TYPE
-
- def getLine(self):
- return 0
-
- def getColumn(self):
- return 0
-
- def getNumberOfChildren(self):
- return 0
-
- def initialize(self, t, txt):
- pass
-
- def initialize(self, t):
- pass
-
- def setFirstChild(self, c):
- pass
-
- def setNextSibling(self, n):
- pass
-
- def setText(self, text):
- pass
-
- def setType(self, ttype):
- pass
-
- def toString(self):
- self.getText()
-
- __str__ = toString
-
- def toStringList(self):
- return self.getText()
-
- def toStringTree(self):
- return self.getText()
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### ASTNULLType ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-### There is only one instance of this class **/
-class ASTNULLType(AST):
- def __init__(self):
- AST.__init__(self)
- pass
-
- def getText(self):
- return "<ASTNULL>"
-
- def getType(self):
- return NULL_TREE_LOOKAHEAD
-
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### BaseAST ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class BaseAST(AST):
-
- verboseStringConversion = False
- tokenNames = None
-
- def __init__(self):
- self.down = None ## kid
- self.right = None ## sibling
-
- def addChild(self,node):
- if node:
- t = rightmost(self.down)
- if t:
- t.right = node
- else:
- assert not self.down
- self.down = node
-
- def getNumberOfChildren(self):
- t = self.down
- n = 0
- while t:
- n += 1
- t = t.right
- return n
-
- def doWorkForFindAll(self,v,target,partialMatch):
- sibling = self
-
- while sibling:
- c1 = partialMatch and sibling.equalsTreePartial(target)
- if c1:
- v.append(sibling)
- else:
- c2 = not partialMatch and sibling.equalsTree(target)
- if c2:
- v.append(sibling)
-
- ### regardless of match or not, check any children for matches
- if sibling.getFirstChild():
- sibling.getFirstChild().doWorkForFindAll(v,target,partialMatch)
-
- sibling = sibling.getNextSibling()
-
- ### Is node t equal to 'self' in terms of token type and text?
- def equals(self,t):
- if not t:
- return False
- return self.getText() == t.getText() and self.getType() == t.getType()
-
- ### Is t an exact structural and equals() match of this tree. The
- ### 'self' reference is considered the start of a sibling list.
- ###
- def equalsList(self, t):
- return cmptree(self, t, partial=False)
-
- ### Is 't' a subtree of this list?
- ### The siblings of the root are NOT ignored.
- ###
- def equalsListPartial(self,t):
- return cmptree(self,t,partial=True)
-
- ### Is tree rooted at 'self' equal to 't'? The siblings
- ### of 'self' are ignored.
- ###
- def equalsTree(self, t):
- return self.equals(t) and \
- cmptree(self.getFirstChild(), t.getFirstChild(), partial=False)
-
- ### Is 't' a subtree of the tree rooted at 'self'? The siblings
- ### of 'self' are ignored.
- ###
- def equalsTreePartial(self, t):
- if not t:
- return True
- return self.equals(t) and cmptree(
- self.getFirstChild(), t.getFirstChild(), partial=True)
-
- ### Walk the tree looking for all exact subtree matches. Return
- ### an ASTEnumerator that lets the caller walk the list
- ### of subtree roots found herein.
- def findAll(self,target):
- roots = []
-
- ### the empty tree cannot result in an enumeration
- if not target:
- return None
- # find all matches recursively
- self.doWorkForFindAll(roots, target, False)
- return roots
-
- ### Walk the tree looking for all subtrees. Return
- ### an ASTEnumerator that lets the caller walk the list
- ### of subtree roots found herein.
- def findAllPartial(self,sub):
- roots = []
-
- ### the empty tree cannot result in an enumeration
- if not sub:
- return None
-
- self.doWorkForFindAll(roots, sub, True) ### find all matches recursively
- return roots
-
- ### Get the first child of this node None if not children
- def getFirstChild(self):
- return self.down
-
- ### Get the next sibling in line after this one
- def getNextSibling(self):
- return self.right
-
- ### Get the token text for this node
- def getText(self):
- return ""
-
- ### Get the token type for this node
- def getType(self):
- return 0
-
- def getLine(self):
- return 0
-
- def getColumn(self):
- return 0
-
- ### Remove all children */
- def removeChildren(self):
- self.down = None
-
- def setFirstChild(self,c):
- self.down = c
-
- def setNextSibling(self, n):
- self.right = n
-
- ### Set the token text for this node
- def setText(self, text):
- pass
-
- ### Set the token type for this node
- def setType(self, ttype):
- pass
-
- ### static
- def setVerboseStringConversion(verbose,names):
- verboseStringConversion = verbose
- tokenNames = names
- setVerboseStringConversion = staticmethod(setVerboseStringConversion)
-
- ### Return an array of strings that maps token ID to it's text.
- ## @since 2.7.3
- def getTokenNames():
- return tokenNames
-
- def toString(self):
- return self.getText()
-
- ### return tree as lisp string - sibling included
- def toStringList(self):
- ts = self.toStringTree()
- sib = self.getNextSibling()
- if sib:
- ts += sib.toStringList()
- return ts
-
- __str__ = toStringList
-
- ### return tree as string - siblings ignored
- def toStringTree(self):
- ts = ""
- kid = self.getFirstChild()
- if kid:
- ts += " ("
- ts += " " + self.toString()
- if kid:
- ts += kid.toStringList()
- ts += " )"
- return ts
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### CommonAST ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-### Common AST node implementation
-class CommonAST(BaseAST):
- def __init__(self,token=None):
- super(CommonAST,self).__init__()
- self.ttype = INVALID_TYPE
- self.text = "<no text>"
- self.line = 0
- self.column= 0
- self.initialize(token)
- #assert self.text
-
- ### Get the token text for this node
- def getText(self):
- return self.text
-
- ### Get the token type for this node
- def getType(self):
- return self.ttype
-
- ### Get the line for this node
- def getLine(self):
- return self.line
-
- ### Get the column for this node
- def getColumn(self):
- return self.column
-
- def initialize(self,*args):
- if not args:
- return
-
- arg0 = args[0]
-
- if isinstance(arg0,int):
- arg1 = args[1]
- self.setType(arg0)
- self.setText(arg1)
- return
-
- if isinstance(arg0,AST) or isinstance(arg0,Token):
- self.setText(arg0.getText())
- self.setType(arg0.getType())
- self.line = arg0.getLine()
- self.column = arg0.getColumn()
- return
-
- ### Set the token text for this node
- def setText(self,text_):
- assert is_string_type(text_)
- self.text = text_
-
- ### Set the token type for this node
- def setType(self,ttype_):
- assert isinstance(ttype_,int)
- self.ttype = ttype_
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### CommonASTWithHiddenTokens ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class CommonASTWithHiddenTokens(CommonAST):
-
- def __init__(self,*args):
- CommonAST.__init__(self,*args)
- self.hiddenBefore = None
- self.hiddenAfter = None
-
- def getHiddenAfter(self):
- return self.hiddenAfter
-
- def getHiddenBefore(self):
- return self.hiddenBefore
-
- def initialize(self,*args):
- CommonAST.initialize(self,*args)
- if args and isinstance(args[0],Token):
- assert isinstance(args[0],CommonHiddenStreamToken)
- self.hiddenBefore = args[0].getHiddenBefore()
- self.hiddenAfter = args[0].getHiddenAfter()
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### ASTPair ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class ASTPair(object):
- def __init__(self):
- self.root = None ### current root of tree
- self.child = None ### current child to which siblings are added
-
- ### Make sure that child is the last sibling */
- def advanceChildToEnd(self):
- if self.child:
- while self.child.getNextSibling():
- self.child = self.child.getNextSibling()
-
- ### Copy an ASTPair. Don't call it clone() because we want type-safety */
- def copy(self):
- tmp = ASTPair()
- tmp.root = self.root
- tmp.child = self.child
- return tmp
-
- def toString(self):
- r = ifelse(not root,"null",self.root.getText())
- c = ifelse(not child,"null",self.child.getText())
- return "[%s,%s]" % (r,c)
-
- __str__ = toString
- __repr__ = toString
-
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### ASTFactory ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class ASTFactory(object):
- def __init__(self,table=None):
- self._class = None
- self._classmap = ifelse(table,table,None)
-
- def create(self,*args):
- if not args:
- return self.create(INVALID_TYPE)
-
- arg0 = args[0]
- arg1 = None
- arg2 = None
-
- try:
- arg1 = args[1]
- arg2 = args[2]
- except:
- pass
-
- # ctor(int)
- if isinstance(arg0,int) and not arg2:
- ### get class for 'self' type
- c = self.getASTNodeType(arg0)
- t = self.create(c)
- if t:
- t.initialize(arg0, ifelse(arg1,arg1,""))
- return t
-
- # ctor(int,something)
- if isinstance(arg0,int) and arg2:
- t = self.create(arg2)
- if t:
- t.initialize(arg0,arg1)
- return t
-
- # ctor(AST)
- if isinstance(arg0,AST):
- t = self.create(arg0.getType())
- if t:
- t.initialize(arg0)
- return t
-
- # ctor(token)
- if isinstance(arg0,Token) and not arg1:
- ttype = arg0.getType()
- assert isinstance(ttype,int)
- t = self.create(ttype)
- if t:
- t.initialize(arg0)
- return t
-
- # ctor(token,class)
- if isinstance(arg0,Token) and arg1:
- assert isinstance(arg1,type)
- assert issubclass(arg1,AST)
- # this creates instance of 'arg1' using 'arg0' as
- # argument. Wow, that's magic!
- t = arg1(arg0)
- assert t and isinstance(t,AST)
- return t
-
- # ctor(class)
- if isinstance(arg0,type):
- ### next statement creates instance of type (!)
- t = arg0()
- assert isinstance(t,AST)
- return t
-
-
- def setASTNodeClass(self,className=None):
- if not className:
- return
- assert isinstance(className,type)
- assert issubclass(className,AST)
- self._class = className
-
- ### kind of misnomer - use setASTNodeClass instead.
- setASTNodeType = setASTNodeClass
-
- def getASTNodeClass(self):
- return self._class
-
-
-
- def getTokenTypeToASTClassMap(self):
- return self._classmap
-
- def setTokenTypeToASTClassMap(self,amap):
- self._classmap = amap
-
- def error(self, e):
- import sys
- print >> sys.stderr, e
-
- def setTokenTypeASTNodeType(self, tokenType, className):
- """
- Specify a mapping between a token type and a (AST) class.
- """
- if not self._classmap:
- self._classmap = {}
-
- if not className:
- try:
- del self._classmap[tokenType]
- except:
- pass
- else:
- ### here we should also perform actions to ensure that
- ### a. class can be loaded
- ### b. class is a subclass of AST
- ###
- assert isinstance(className,type)
- assert issubclass(className,AST) ## a & b
- ### enter the class
- self._classmap[tokenType] = className
-
- def getASTNodeType(self,tokenType):
- """
- For a given token type return the AST node type. First we
- lookup a mapping table, second we try _class
- and finally we resolve to "antlr.CommonAST".
- """
-
- # first
- if self._classmap:
- try:
- c = self._classmap[tokenType]
- if c:
- return c
- except:
- pass
- # second
- if self._class:
- return self._class
-
- # default
- return CommonAST
-
- ### methods that have been moved to file scope - just listed
- ### here to be somewhat consistent with original API
- def dup(self,t):
- return antlr.dup(t,self)
-
- def dupList(self,t):
- return antlr.dupList(t,self)
-
- def dupTree(self,t):
- return antlr.dupTree(t,self)
-
- ### methods moved to other classes
- ### 1. makeASTRoot -> Parser
- ### 2. addASTChild -> Parser
-
- ### non-standard: create alias for longish method name
- maptype = setTokenTypeASTNodeType
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### ASTVisitor ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-class ASTVisitor(object):
- def __init__(self,*args):
- pass
-
- def visit(self,ast):
- pass
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-### static methods and variables ###
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx###
-
-ASTNULL = ASTNULLType()
-
-### wh: moved from ASTFactory as there's nothing ASTFactory-specific
-### in this method.
-def make(*nodes):
- if not nodes:
- return None
-
- for i in xrange(0,len(nodes)):
- node = nodes[i]
- if node:
- assert isinstance(node,AST)
-
- root = nodes[0]
- tail = None
- if root:
- root.setFirstChild(None)
-
- for i in xrange(1,len(nodes)):
- if not nodes[i]:
- continue
- if not root:
- root = tail = nodes[i]
- elif not tail:
- root.setFirstChild(nodes[i])
- tail = root.getFirstChild()
- else:
- tail.setNextSibling(nodes[i])
- tail = tail.getNextSibling()
-
- ### Chase tail to last sibling
- while tail.getNextSibling():
- tail = tail.getNextSibling()
- return root
-
-def dup(t,factory):
- if not t:
- return None
-
- if factory:
- dup_t = factory.create(t.__class__)
- else:
- raise TypeError("dup function requires ASTFactory argument")
- dup_t.initialize(t)
- return dup_t
-
-def dupList(t,factory):
- result = dupTree(t,factory)
- nt = result
- while t:
- ## for each sibling of the root
- t = t.getNextSibling()
- nt.setNextSibling(dupTree(t,factory))
- nt = nt.getNextSibling()
- return result
-
-def dupTree(t,factory):
- result = dup(t,factory)
- if t:
- result.setFirstChild(dupList(t.getFirstChild(),factory))
- return result
-
-###xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
-### $Id: antlr.py 3750 2009-02-13 00:13:04Z sjmachin $
-
-# Local Variables: ***
-# mode: python ***
-# py-indent-offset: 4 ***
-# End: ***
diff --git a/tablib/packages/xlwt/doc/xlwt.html b/tablib/packages/xlwt/doc/xlwt.html deleted file mode 100644 index a05128d..0000000 --- a/tablib/packages/xlwt/doc/xlwt.html +++ /dev/null @@ -1,199 +0,0 @@ -<!DOCTYPE html PUBLIC '-//W3C//DTD XHTML 1.0 Strict//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd'>
-<html>
-<head>
-<meta http-equiv='Content-Type' content='text/html; charset=us-ascii' />
-<title>The xlwt Module</title>
-</head>
-<body>
-<h1>The xlwt Module</h1>
-<p /><p><b>A Python package for generating Microsoft Excel ™ spreadsheet files.
-</b></p>
-
-<h2>General information</h2>
-
-<h3>State of Documentation</h3>
-
-<p>
-This documentation is currently incomplete. There may be methods and
-classes not included and any item marked with a <em
-style="color:red;">[NC]</em> is not complete and may have further
-parameters, methods, attributes and functionality that are not
-documented. In these cases, you'll have to refer to the source if the
-documentation provided is insufficient.
-</p>
-
-</p>
-
-<h2>Module Contents <em style="color:red;">[NC]</em></h2>
-<dl>
- <dt><b>easyxf</b> (function)</dt>
- <dd>
- <p>
- This function is used to create and configure XFStyle objects
- for use with (for example) the Worksheet.write method.
- </p>
- <dl>
- <dt><i>strg_to_parse</i></dt>
- <dd>
- <p>
- A string to be parsed to obtain attribute values for Alignment, Borders, Font,
- Pattern and Protection objects. Refer to the examples
- in the file .../examples/xlwt_easyxf_simple_demo.py and to the xf_dict
- dictionary in Style.py. Various synonyms including color/colour, center/centre and gray/grey
- are allowed. Case is irrelevant (except maybe in font names). '-' may be used instead
- of '_'.<br />
- Example: "font: bold on; align: wrap on, vert centre, horiz center"
- </p>
- </dd>
- <dt><i>num_format_str</i></dt>
- <dd>
- <p>
- To get the "number format string" of an existing cell whose format you want to reproduce,
- select the cell and click on Format/Cells/Number/Custom. Otherwise, refer to Excel help.<br />
- Examples: "#,##0.00", "dd/mm/yyyy"
- </p>
- </dd>
- <dt>Returns:</dt>
- <dd>
- An object of the XFstyle class
- </dd>
- </dl>
- <br />
-
- </dd>
-
- <dt><b>Workbook</b> (class) [<a href='#xlwt.Workbook-class'>#</a>]</dt>
- <dd>
- <p>The class to instantiate to create a workbook</p>
- <p>For more information about this class, see <a href='#xlwt.Workbook-class'><i>The Workbook Class</i></a>.</p>
- </dd>
- <dt><b>Worksheet</b> (class) [<a href='#xlwt.Worksheet-class'>#</a>]</dt>
- <dd>
- <p>A class to represent the contents of a sheet in a workbook.</p>
- <p>For more information about this class, see <a href='#xlwt.Worksheet-class'><i>The Worksheet Class</i></a>.</p>
- </dd>
-</dl>
-
-<h2><a id='xlwt.Workbook-class' name='xlwt.Workbook-class'>The Workbook Class</a><em style="color:red;">[NC]</em></h2>
-<dl>
-<dt><b>Workbook(encoding='ascii',style_compression=0)</b> (class) [<a href='#xlwt.Workbook-class'>#</a>]</dt>
-<dd>
- <p>
- This is a class representing a workbook and all its contents.
- When creating Excel files with xlwt, you will normally start by
- instantiating an object of this class.
- </p>
- <dl>
- <dt><i>encoding</i></dt>
- <dd>
- <em style="color:red;">[NC]</em>
- </dd>
- <dt><i>style_compression</i></dt>
- <dd>
- <em style="color:red;">[NC]</em>
- </dd>
- <dt>Returns:</dt>
- <dd>
- An object of the <a href="#xlwt.Workbook-class">Workbook</a> class
- </dd>
- </dl>
- <br />
-</dd>
-<dt><a id='xlwt.Workbook.add_sheet-method' name='xlwt.Workbook.add_sheet-method'><b>add_sheet(sheetname)</b></a> [<a href='#xlwt.Workbook.add_sheet-method'>#</a>]</dt>
-<dd>
- <p>
- This method is used to create Worksheets in a Workbook.
- </p>
- <dl>
- <dt><i>sheetname</i></dt>
- <dd>
- The name to use for this sheet, as it will appear in the tabs at
- the bottom of the Excel application.
- </dd>
- <dt>Returns:</dt>
- <dd>
- An object of the <a href="#xlwt.Worksheet-class">Worksheet</a> class
- </dd>
- </dl>
- <br />
-</dd>
-<dt><a id='xlwt.Workbook.save-method' name='xlwt.Workbook.save-method'><b>save(filename_or_stream)</b></a> [<a href='#xlwt.Workbook.save-method'>#</a>]</dt>
-<dd>
- <p>
- This method is used to save Workbook to a file in native Excel format.
- </p>
- <dl>
- <dt><i>filename_or_stream</i></dt>
- <dd>
- <p>
- This can be a string containing a filename of the file, in which case
- the excel file is saved to disk using the name provided.
- </p>
- <p>
- It can also be a stream object with a write method, such as a
- StringIO, in which case the data for the excel file is written
- to the stream.
- </p>
- </dd>
- </dl>
- <br />
-</dd>
-</dl>
-
-<h2><a id='xlwt.Worksheet-class' name='xlwt.Worksheet-class'>The Worksheet Class</a><em style="color:red;">[NC]</em></h2>
-<dl>
-<dt><b>Worksheet(sheetname, parent_book)</b> (class) [<a href='#xlwt.Worksheet-class'>#</a>]</dt>
-<dd>
- <p>
- This is a class representing the contents of a sheet in a workbook.
- </p>
- <p>
- WARNING: You don't normally create instances of this class
- yourself. They are returned from calls to <a href="#xlwt.Workbook.add_sheet-method">Workbook.add_sheet</a>
- </p>
-</dd>
-<dt><a id='xlwt.Worksheet.write-method'
-name='xlwt.Worksheet.write-method'><b>write(r, c, label="", style=Style.default_style)</b></a> [<a href='#xlwt.Worksheet.write-method'>#</a>]</dt>
-<dd>
- <p>
- This method is used to write a cell to a Worksheet..
- </p>
- <dl>
- <dt><i>r</i></dt>
- <dd>
- The zero-relative number of the row in the worksheet to which the cell should be written.
- </dd>
- <dt><i>c</i></dt>
- <dd>
- The zero-relative number of the column in the worksheet to which the cell should be written.
- </dd>
- <dt><i>label</i></dt>
- <dd>
- The data value to be written.
- An int, long, or decimal.Decimal instance is converted to float.
- A unicode instance is written as is.
- A str instance is converted to unicode using the encoding (default: 'ascii') specified
- when the Workbook instance was created.
- A datetime.datetime, datetime.date, or datetime.time instance is converted into Excel date format
- (a float representing the number of days since (typically) 1899-12-31T00:00:00,
- under the pretence that 1900 was a leap year).
- A bool instance will show up as TRUE or FALSE in Excel.
- None causes the cell to be blank -- no data, only formatting.
- An xlwt.Formula instance causes an Excel formula to be written.
- <em style="color:red;">[NC]</em>
- </dd>
- <dt><i>style</i></dt>
- <dd>
- A style -- also known as an XF (extended format) -- is an XFStyle object, which encapsulates
- the formatting applied to the cell and its contents. XFStyle objects are best set up using the
- <i>easyxf</i> function. They may also be set up by setting attributes in
- Alignment, Borders, Pattern, Font and Protection objects
- then setting those objects and a format string as attributes of an XFStyle object.
- <em style="color:red;">[NC]</em>
- </dd>
- </dl>
- <br />
-</dd>
-</dl>
-
-</body></html>
diff --git a/tablib/packages/xlwt/examples/big-16Mb.py b/tablib/packages/xlwt/examples/big-16Mb.py deleted file mode 100644 index 2dcb9fc..0000000 --- a/tablib/packages/xlwt/examples/big-16Mb.py +++ /dev/null @@ -1,35 +0,0 @@ -#!/usr/bin/env python
-# tries stress SST, SAT and MSAT
-
-from time import *
-from xlwt.Workbook import *
-from xlwt.Style import *
-
-style = XFStyle()
-
-wb = Workbook()
-ws0 = wb.add_sheet('0')
-
-colcount = 200 + 1
-rowcount = 6000 + 1
-
-t0 = time()
-print "\nstart: %s" % ctime(t0)
-
-print "Filling..."
-for col in xrange(colcount):
- print "[%d]" % col,
- for row in xrange(rowcount):
- #ws0.write(row, col, "BIG(%d, %d)" % (row, col))
- ws0.write(row, col, "BIG")
-
-t1 = time() - t0
-print "\nsince starting elapsed %.2f s" % (t1)
-
-print "Storing..."
-wb.save('big-16Mb.xls')
-
-t2 = time() - t0
-print "since starting elapsed %.2f s" % (t2)
-
-
diff --git a/tablib/packages/xlwt/examples/big-35Mb.py b/tablib/packages/xlwt/examples/big-35Mb.py deleted file mode 100644 index c2430e9..0000000 --- a/tablib/packages/xlwt/examples/big-35Mb.py +++ /dev/null @@ -1,34 +0,0 @@ -#!/usr/bin/env python
-# tries stress SST, SAT and MSAT
-
-from time import *
-from xlwt import *
-
-style = XFStyle()
-
-wb = Workbook()
-ws0 = wb.add_sheet('0')
-
-colcount = 200 + 1
-rowcount = 6000 + 1
-
-t0 = time()
-print "\nstart: %s" % ctime(t0)
-
-print "Filling..."
-for col in xrange(colcount):
- print "[%d]" % col,
- for row in xrange(rowcount):
- ws0.write(row, col, "BIG(%d, %d)" % (row, col))
- #ws0.write(row, col, "BIG")
-
-t1 = time() - t0
-print "\nsince starting elapsed %.2f s" % (t1)
-
-print "Storing..."
-wb.save('big-35Mb.xls')
-
-t2 = time() - t0
-print "since starting elapsed %.2f s" % (t2)
-
-
diff --git a/tablib/packages/xlwt/examples/blanks.py b/tablib/packages/xlwt/examples/blanks.py deleted file mode 100644 index 3571b2c..0000000 --- a/tablib/packages/xlwt/examples/blanks.py +++ /dev/null @@ -1,36 +0,0 @@ -#!/usr/bin/env python
-# -*- coding: windows-1251 -*-
-# Copyright (C) 2005 Kiseliov Roman
-
-from xlwt import *
-
-font0 = Font()
-font0.name = 'Times New Roman'
-font0.struck_out = True
-font0.bold = True
-
-style0 = XFStyle()
-style0.font = font0
-
-
-wb = Workbook()
-ws0 = wb.add_sheet('0')
-
-ws0.write(1, 1, 'Test', style0)
-
-for i in range(0, 0x53):
- borders = Borders()
- borders.left = i
- borders.right = i
- borders.top = i
- borders.bottom = i
-
- style = XFStyle()
- style.borders = borders
-
- ws0.write(i, 2, '', style)
- ws0.write(i, 3, hex(i), style0)
-
-ws0.write_merge(5, 8, 6, 10, "")
-
-wb.save('blanks.xls')
diff --git a/tablib/packages/xlwt/examples/col_width.py b/tablib/packages/xlwt/examples/col_width.py deleted file mode 100644 index 55d244b..0000000 --- a/tablib/packages/xlwt/examples/col_width.py +++ /dev/null @@ -1,19 +0,0 @@ -#!/usr/bin/env python
-# -*- coding: windows-1251 -*-
-# Copyright (C) 2005 Kiseliov Roman
-__rev_id__ = """$Id: col_width.py 3315 2008-03-14 14:44:52Z chris $"""
-
-
-from xlwt import *
-
-w = Workbook()
-ws = w.add_sheet('Hey, Dude')
-
-for i in range(6, 80):
- fnt = Font()
- fnt.height = i*20
- style = XFStyle()
- style.font = fnt
- ws.write(1, i, 'Test')
- ws.col(i).width = 0x0d00 + i
-w.save('col_width.xls')
diff --git a/tablib/packages/xlwt/examples/country.py b/tablib/packages/xlwt/examples/country.py deleted file mode 100644 index d29cd97..0000000 --- a/tablib/packages/xlwt/examples/country.py +++ /dev/null @@ -1,10 +0,0 @@ -#!/usr/bin/env python
-# -*- coding: windows-1252 -*-
-# Copyright (C) 2007 John Machin
-
-from xlwt import *
-
-w = Workbook()
-w.country_code = 61
-ws = w.add_sheet('AU')
-w.save('country.xls')
diff --git a/tablib/packages/xlwt/examples/dates.py b/tablib/packages/xlwt/examples/dates.py deleted file mode 100644 index efe28a0..0000000 --- a/tablib/packages/xlwt/examples/dates.py +++ /dev/null @@ -1,37 +0,0 @@ -#!/usr/bin/env python
-# -*- coding: windows-1251 -*-
-# Copyright (C) 2005 Kiseliov Roman
-
-from xlwt import *
-from datetime import datetime
-
-w = Workbook()
-ws = w.add_sheet('Hey, Dude')
-
-fmts = [
- 'M/D/YY',
- 'D-MMM-YY',
- 'D-MMM',
- 'MMM-YY',
- 'h:mm AM/PM',
- 'h:mm:ss AM/PM',
- 'h:mm',
- 'h:mm:ss',
- 'M/D/YY h:mm',
- 'mm:ss',
- '[h]:mm:ss',
- 'mm:ss.0',
-]
-
-i = 0
-for fmt in fmts:
- ws.write(i, 0, fmt)
-
- style = XFStyle()
- style.num_format_str = fmt
-
- ws.write(i, 4, datetime.now(), style)
-
- i += 1
-
-w.save('dates.xls')
diff --git a/tablib/packages/xlwt/examples/format.py b/tablib/packages/xlwt/examples/format.py deleted file mode 100644 index 687127c..0000000 --- a/tablib/packages/xlwt/examples/format.py +++ /dev/null @@ -1,38 +0,0 @@ -#!/usr/bin/env python
-# -*- coding: windows-1251 -*-
-# Copyright (C) 2005 Kiseliov Roman
-
-from xlwt import *
-
-font0 = Font()
-font0.name = 'Times New Roman'
-font0.struck_out = True
-font0.bold = True
-
-style0 = XFStyle()
-style0.font = font0
-
-
-wb = Workbook()
-ws0 = wb.add_sheet('0')
-
-ws0.write(1, 1, 'Test', style0)
-
-for i in range(0, 0x53):
- fnt = Font()
- fnt.name = 'Arial'
- fnt.colour_index = i
- fnt.outline = True
-
- borders = Borders()
- borders.left = i
-
- style = XFStyle()
- style.font = fnt
- style.borders = borders
-
- ws0.write(i, 2, 'colour', style)
- ws0.write(i, 3, hex(i), style0)
-
-
-wb.save('format.xls')
diff --git a/tablib/packages/xlwt/examples/formula_names.py b/tablib/packages/xlwt/examples/formula_names.py deleted file mode 100644 index 8bd3247..0000000 --- a/tablib/packages/xlwt/examples/formula_names.py +++ /dev/null @@ -1,34 +0,0 @@ -#!/usr/bin/env python
-# -*- coding: windows-1251 -*-
-# Copyright (C) 2005 Kiseliov Roman
-
-from xlwt import *
-from xlwt.ExcelFormulaParser import FormulaParseException
-
-w = Workbook()
-ws = w.add_sheet('F')
-
-## This example is a little silly since the formula building is
-## so simplistic that it often fails because the generated text
-## has the wrong number of parameters for the function being
-## tested.
-
-i = 0
-succeed_count = 0
-fail_count = 0
-for n in sorted(ExcelMagic.std_func_by_name):
- ws.write(i, 0, n)
- text = n + "($A$1)"
- try:
- formula = Formula(text)
- except FormulaParseException,e:
- print "Could not parse %r: %s" % (text,e.args[0])
- fail_count += 1
- else:
- ws.write(i, 3, formula)
- succeed_count += 1
- i += 1
-
-w.save('formula_names.xls')
-
-print "succeeded with %i functions, failed with %i" % (succeed_count,fail_count)
diff --git a/tablib/packages/xlwt/examples/formulas.py b/tablib/packages/xlwt/examples/formulas.py deleted file mode 100644 index 4eef78b..0000000 --- a/tablib/packages/xlwt/examples/formulas.py +++ /dev/null @@ -1,47 +0,0 @@ -#!/usr/bin/env python
-# -*- coding: windows-1251 -*-
-# Copyright (C) 2005 Kiseliov Roman
-
-from xlwt import *
-
-w = Workbook()
-ws = w.add_sheet('F')
-
-ws.write(0, 0, Formula("-(1+1)"))
-ws.write(1, 0, Formula("-(1+1)/(-2-2)"))
-ws.write(2, 0, Formula("-(134.8780789+1)"))
-ws.write(3, 0, Formula("-(134.8780789e-10+1)"))
-ws.write(4, 0, Formula("-1/(1+1)+9344"))
-
-ws.write(0, 1, Formula("-(1+1)"))
-ws.write(1, 1, Formula("-(1+1)/(-2-2)"))
-ws.write(2, 1, Formula("-(134.8780789+1)"))
-ws.write(3, 1, Formula("-(134.8780789e-10+1)"))
-ws.write(4, 1, Formula("-1/(1+1)+9344"))
-
-ws.write(0, 2, Formula("A1*B1"))
-ws.write(1, 2, Formula("A2*B2"))
-ws.write(2, 2, Formula("A3*B3"))
-ws.write(3, 2, Formula("A4*B4*sin(pi()/4)"))
-ws.write(4, 2, Formula("A5%*B5*pi()/1000"))
-
-##############
-## NOTE: parameters are separated by semicolon!!!
-##############
-
-
-ws.write(5, 2, Formula("C1+C2+C3+C4+C5/(C1+C2+C3+C4/(C1+C2+C3+C4/(C1+C2+C3+C4)+C5)+C5)-20.3e-2"))
-ws.write(5, 3, Formula("C1^2"))
-ws.write(6, 2, Formula("SUM(C1;C2;;;;;C3;;;C4)"))
-ws.write(6, 3, Formula("SUM($A$1:$C$5)"))
-
-ws.write(7, 0, Formula('"lkjljllkllkl"'))
-ws.write(7, 1, Formula('"yuyiyiyiyi"'))
-ws.write(7, 2, Formula('A8 & B8 & A8'))
-ws.write(8, 2, Formula('now()'))
-
-ws.write(10, 2, Formula('TRUE'))
-ws.write(11, 2, Formula('FALSE'))
-ws.write(12, 3, Formula('IF(A1>A2;3;"hkjhjkhk")'))
-
-w.save('formulas.xls')
diff --git a/tablib/packages/xlwt/examples/hyperlinks.py b/tablib/packages/xlwt/examples/hyperlinks.py deleted file mode 100644 index e5496a8..0000000 --- a/tablib/packages/xlwt/examples/hyperlinks.py +++ /dev/null @@ -1,28 +0,0 @@ -#!/usr/bin/env python
-# -*- coding: windows-1251 -*-
-# Copyright (C) 2005 Kiseliov Roman
-
-from xlwt import *
-
-f = Font()
-f.height = 20*72
-f.name = 'Verdana'
-f.bold = True
-f.underline = Font.UNDERLINE_DOUBLE
-f.colour_index = 4
-
-h_style = XFStyle()
-h_style.font = f
-
-w = Workbook()
-ws = w.add_sheet('F')
-
-##############
-## NOTE: parameters are separated by semicolon!!!
-##############
-
-n = "HYPERLINK"
-ws.write_merge(1, 1, 1, 10, Formula(n + '("http://www.irs.gov/pub/irs-pdf/f1000.pdf";"f1000.pdf")'), h_style)
-ws.write_merge(2, 2, 2, 25, Formula(n + '("mailto:roman.kiseliov@gmail.com?subject=pyExcelerator-feedback&Body=Hello,%20Roman!";"pyExcelerator-feedback")'), h_style)
-
-w.save("hyperlinks.xls")
diff --git a/tablib/packages/xlwt/examples/image.py b/tablib/packages/xlwt/examples/image.py deleted file mode 100644 index aadd7cd..0000000 --- a/tablib/packages/xlwt/examples/image.py +++ /dev/null @@ -1,12 +0,0 @@ -#!/usr/bin/env python
-# -*- coding: windows-1251 -*-
-# Copyright (C) 2005 Kiseliov Roman
-
-from xlwt import *
-
-w = Workbook()
-ws = w.add_sheet('Image')
-ws.insert_bitmap('python.bmp', 2, 2)
-ws.insert_bitmap('python.bmp', 10, 2)
-
-w.save('image.xls')
diff --git a/tablib/packages/xlwt/examples/merged.py b/tablib/packages/xlwt/examples/merged.py deleted file mode 100644 index 41f7e2a..0000000 --- a/tablib/packages/xlwt/examples/merged.py +++ /dev/null @@ -1,39 +0,0 @@ -#!/usr/bin/env python
-# -*- coding: windows-1251 -*-
-# Copyright (C) 2005 Kiseliov Roman
-
-from xlwt import *
-
-fnt = Font()
-fnt.name = 'Arial'
-fnt.colour_index = 4
-fnt.bold = True
-
-borders = Borders()
-borders.left = 6
-borders.right = 6
-borders.top = 6
-borders.bottom = 6
-
-al = Alignment()
-al.horz = Alignment.HORZ_CENTER
-al.vert = Alignment.VERT_CENTER
-
-style = XFStyle()
-style.font = fnt
-style.borders = borders
-style.alignment = al
-
-
-wb = Workbook()
-ws0 = wb.add_sheet('sheet0')
-ws1 = wb.add_sheet('sheet1')
-ws2 = wb.add_sheet('sheet2')
-
-for i in range(0, 0x200, 2):
- ws0.write_merge(i, i+1, 1, 5, 'test %d' % i, style)
- ws1.write_merge(i, i, 1, 7, 'test %d' % i, style)
- ws2.write_merge(i, i+1, 1, 7 + (i%10), 'test %d' % i, style)
-
-
-wb.save('merged.xls')
diff --git a/tablib/packages/xlwt/examples/merged0.py b/tablib/packages/xlwt/examples/merged0.py deleted file mode 100644 index 7dad374..0000000 --- a/tablib/packages/xlwt/examples/merged0.py +++ /dev/null @@ -1,30 +0,0 @@ -#!/usr/bin/env python
-# -*- coding: windows-1251 -*-
-# Copyright (C) 2005 Kiseliov Roman
-
-from xlwt import *
-
-wb = Workbook()
-ws0 = wb.add_sheet('sheet0')
-
-
-fnt = Font()
-fnt.name = 'Arial'
-fnt.colour_index = 4
-fnt.bold = True
-
-borders = Borders()
-borders.left = 6
-borders.right = 6
-borders.top = 6
-borders.bottom = 6
-
-style = XFStyle()
-style.font = fnt
-style.borders = borders
-
-ws0.write_merge(3, 3, 1, 5, 'test1', style)
-ws0.write_merge(4, 10, 1, 5, 'test2', style)
-ws0.col(1).width = 0x0d00
-
-wb.save('merged0.xls')
diff --git a/tablib/packages/xlwt/examples/merged1.py b/tablib/packages/xlwt/examples/merged1.py deleted file mode 100644 index 0e67968..0000000 --- a/tablib/packages/xlwt/examples/merged1.py +++ /dev/null @@ -1,102 +0,0 @@ -#!/usr/bin/env python
-# -*- coding: windows-1251 -*-
-# Copyright (C) 2005 Kiseliov Roman
-
-from xlwt import *
-
-wb = Workbook()
-ws0 = wb.add_sheet('sheet0')
-
-fnt1 = Font()
-fnt1.name = 'Verdana'
-fnt1.bold = True
-fnt1.height = 18*0x14
-
-pat1 = Pattern()
-pat1.pattern = Pattern.SOLID_PATTERN
-pat1.pattern_fore_colour = 0x16
-
-brd1 = Borders()
-brd1.left = 0x06
-brd1.right = 0x06
-brd1.top = 0x06
-brd1.bottom = 0x06
-
-fnt2 = Font()
-fnt2.name = 'Verdana'
-fnt2.bold = True
-fnt2.height = 14*0x14
-
-brd2 = Borders()
-brd2.left = 0x01
-brd2.right = 0x01
-brd2.top = 0x01
-brd2.bottom = 0x01
-
-pat2 = Pattern()
-pat2.pattern = Pattern.SOLID_PATTERN
-pat2.pattern_fore_colour = 0x01F
-
-fnt3 = Font()
-fnt3.name = 'Verdana'
-fnt3.bold = True
-fnt3.italic = True
-fnt3.height = 12*0x14
-
-brd3 = Borders()
-brd3.left = 0x07
-brd3.right = 0x07
-brd3.top = 0x07
-brd3.bottom = 0x07
-
-fnt4 = Font()
-
-al1 = Alignment()
-al1.horz = Alignment.HORZ_CENTER
-al1.vert = Alignment.VERT_CENTER
-
-al2 = Alignment()
-al2.horz = Alignment.HORZ_RIGHT
-al2.vert = Alignment.VERT_CENTER
-
-al3 = Alignment()
-al3.horz = Alignment.HORZ_LEFT
-al3.vert = Alignment.VERT_CENTER
-
-style1 = XFStyle()
-style1.font = fnt1
-style1.alignment = al1
-style1.pattern = pat1
-style1.borders = brd1
-
-style2 = XFStyle()
-style2.font = fnt2
-style2.alignment = al1
-style2.pattern = pat2
-style2.borders = brd2
-
-style3 = XFStyle()
-style3.font = fnt3
-style3.alignment = al1
-style3.pattern = pat2
-style3.borders = brd3
-
-price_style = XFStyle()
-price_style.font = fnt4
-price_style.alignment = al2
-price_style.borders = brd3
-price_style.num_format_str = '_(#,##0.00_) "money"'
-
-ware_style = XFStyle()
-ware_style.font = fnt4
-ware_style.alignment = al3
-ware_style.borders = brd3
-
-
-ws0.merge(3, 3, 1, 5, style1)
-ws0.merge(4, 10, 1, 6, style2)
-ws0.merge(14, 16, 1, 7, style3)
-ws0.col(1).width = 0x0d00
-
-
-wb.save('merged1.xls')
diff --git a/tablib/packages/xlwt/examples/mini.py b/tablib/packages/xlwt/examples/mini.py deleted file mode 100644 index 61bb30c..0000000 --- a/tablib/packages/xlwt/examples/mini.py +++ /dev/null @@ -1,9 +0,0 @@ -#!/usr/bin/env python -# -*- coding: windows-1251 -*- -# Copyright (C) 2005 Kiseliov Roman - -from xlwt import * - -w = Workbook() -ws = w.add_sheet('xlwt was here') -w.save('mini.xls') diff --git a/tablib/packages/xlwt/examples/mini.xls b/tablib/packages/xlwt/examples/mini.xls Binary files differdeleted file mode 100644 index e70f8dd..0000000 --- a/tablib/packages/xlwt/examples/mini.xls +++ /dev/null diff --git a/tablib/packages/xlwt/examples/num_formats.py b/tablib/packages/xlwt/examples/num_formats.py deleted file mode 100644 index 637a197..0000000 --- a/tablib/packages/xlwt/examples/num_formats.py +++ /dev/null @@ -1,60 +0,0 @@ -#!/usr/bin/env python
-# -*- coding: windows-1251 -*-
-# Copyright (C) 2005 Kiseliov Roman
-
-from xlwt import *
-
-w = Workbook()
-ws = w.add_sheet('Hey, Dude')
-
-fmts = [
- 'general',
- '0',
- '0.00',
- '#,##0',
- '#,##0.00',
- '"$"#,##0_);("$"#,##',
- '"$"#,##0_);[Red]("$"#,##',
- '"$"#,##0.00_);("$"#,##',
- '"$"#,##0.00_);[Red]("$"#,##',
- '0%',
- '0.00%',
- '0.00E+00',
- '# ?/?',
- '# ??/??',
- 'M/D/YY',
- 'D-MMM-YY',
- 'D-MMM',
- 'MMM-YY',
- 'h:mm AM/PM',
- 'h:mm:ss AM/PM',
- 'h:mm',
- 'h:mm:ss',
- 'M/D/YY h:mm',
- '_(#,##0_);(#,##0)',
- '_(#,##0_);[Red](#,##0)',
- '_(#,##0.00_);(#,##0.00)',
- '_(#,##0.00_);[Red](#,##0.00)',
- '_("$"* #,##0_);_("$"* (#,##0);_("$"* "-"_);_(@_)',
- '_(* #,##0_);_(* (#,##0);_(* "-"_);_(@_)',
- '_("$"* #,##0.00_);_("$"* (#,##0.00);_("$"* "-"??_);_(@_)',
- '_(* #,##0.00_);_(* (#,##0.00);_(* "-"??_);_(@_)',
- 'mm:ss',
- '[h]:mm:ss',
- 'mm:ss.0',
- '##0.0E+0',
- '@'
-]
-
-i = 0
-for fmt in fmts:
- ws.write(i, 0, fmt)
-
- style = XFStyle()
- style.num_format_str = fmt
-
- ws.write(i, 4, -1278.9078, style)
-
- i += 1
-
-w.save('num_formats.xls')
diff --git a/tablib/packages/xlwt/examples/numbers.py b/tablib/packages/xlwt/examples/numbers.py deleted file mode 100644 index 475f76c..0000000 --- a/tablib/packages/xlwt/examples/numbers.py +++ /dev/null @@ -1,25 +0,0 @@ -#!/usr/bin/env python
-# -*- coding: windows-1251 -*-
-# Copyright (C) 2005 Kiseliov Roman
-
-from xlwt import *
-
-w = Workbook()
-ws = w.add_sheet('Hey, Dude')
-
-ws.write(0, 0, 1)
-ws.write(1, 0, 1.23)
-ws.write(2, 0, 12345678)
-ws.write(3, 0, 123456.78)
-
-ws.write(0, 1, -1)
-ws.write(1, 1, -1.23)
-ws.write(2, 1, -12345678)
-ws.write(3, 1, -123456.78)
-
-ws.write(0, 2, -17867868678687.0)
-ws.write(1, 2, -1.23e-5)
-ws.write(2, 2, -12345678.90780980)
-ws.write(3, 2, -123456.78)
-
-w.save('numbers.xls')
diff --git a/tablib/packages/xlwt/examples/outline.py b/tablib/packages/xlwt/examples/outline.py deleted file mode 100644 index b20ecf4..0000000 --- a/tablib/packages/xlwt/examples/outline.py +++ /dev/null @@ -1,60 +0,0 @@ -#!/usr/bin/env python
-# -*- coding: ascii -*-
-# Portions Copyright (C) 2005 Kiseliov Roman
-
-import xlwt
-
-style = xlwt.easyxf(
- "font: name Arial, colour_index blue, bold on;"
- "borders: top double, bottom double, left double, right double;"
- )
-
-def write_data_cells(ws):
- ws.write_merge(1, 1, 1, 5, 'test 1', style)
- ws.write_merge(2, 2, 1, 4, 'test 1', style)
- ws.write_merge(3, 3, 1, 3, 'test 2', style)
- ws.write_merge(4, 4, 1, 4, 'test 1', style)
- ws.write_merge(5, 5, 1, 4, 'test 3', style)
- ws.write_merge(6, 6, 1, 5, 'test 1', style)
- ws.write_merge(7, 7, 1, 5, 'test 4', style)
- ws.write_merge(8, 8, 1, 4, 'test 1', style)
- ws.write_merge(9, 9, 1, 3, 'test 5', style)
-
-def write_row_outline_levels(ws):
- ws.row(1).level = 1
- ws.row(2).level = 1
- ws.row(3).level = 2
- ws.row(4).level = 2
- ws.row(5).level = 2
- ws.row(6).level = 2
- ws.row(7).level = 2
- ws.row(8).level = 1
- ws.row(9).level = 1
-
-def write_column_outline_levels(ws):
- ws.col(1).level = 1
- ws.col(2).level = 1
- ws.col(3).level = 2
- ws.col(4).level = 2
- ws.col(5).level = 2
- ws.col(6).level = 2
- ws.col(7).level = 2
- ws.col(8).level = 1
- ws.col(9).level = 1
-
-wb = xlwt.Workbook()
-
-ws0 = wb.add_sheet('Rows Outline')
-write_data_cells(ws0)
-write_row_outline_levels(ws0)
-
-ws1 = wb.add_sheet('Columns Outline')
-write_data_cells(ws1)
-write_column_outline_levels(ws1)
-
-ws2 = wb.add_sheet('Rows and Columns Outline')
-write_data_cells(ws2)
-write_row_outline_levels(ws2)
-write_column_outline_levels(ws2)
-
-wb.save('outline.xls')
diff --git a/tablib/packages/xlwt/examples/panes.py b/tablib/packages/xlwt/examples/panes.py deleted file mode 100644 index f81727f..0000000 --- a/tablib/packages/xlwt/examples/panes.py +++ /dev/null @@ -1,58 +0,0 @@ -#!/usr/bin/env python
-# -*- coding: windows-1251 -*-
-# Copyright (C) 2005 Kiseliov Roman
-
-from xlwt import *
-
-w = Workbook()
-ws1 = w.add_sheet('sheet 1')
-ws2 = w.add_sheet('sheet 2')
-ws3 = w.add_sheet('sheet 3')
-ws4 = w.add_sheet('sheet 4')
-ws5 = w.add_sheet('sheet 5')
-ws6 = w.add_sheet('sheet 6')
-
-for i in range(0x100):
- ws1.write(i/0x10, i%0x10, i)
-
-for i in range(0x100):
- ws2.write(i/0x10, i%0x10, i)
-
-for i in range(0x100):
- ws3.write(i/0x10, i%0x10, i)
-
-for i in range(0x100):
- ws4.write(i/0x10, i%0x10, i)
-
-for i in range(0x100):
- ws5.write(i/0x10, i%0x10, i)
-
-for i in range(0x100):
- ws6.write(i/0x10, i%0x10, i)
-
-ws1.panes_frozen = True
-ws1.horz_split_pos = 2
-
-ws2.panes_frozen = True
-ws2.vert_split_pos = 2
-
-ws3.panes_frozen = True
-ws3.horz_split_pos = 1
-ws3.vert_split_pos = 1
-
-ws4.panes_frozen = False
-ws4.horz_split_pos = 12
-ws4.horz_split_first_visible = 2
-
-ws5.panes_frozen = False
-ws5.vert_split_pos = 40
-ws4.vert_split_first_visible = 2
-
-ws6.panes_frozen = False
-ws6.horz_split_pos = 12
-ws4.horz_split_first_visible = 2
-ws6.vert_split_pos = 40
-ws4.vert_split_first_visible = 2
-
-w.save('panes.xls')
-
diff --git a/tablib/packages/xlwt/examples/parse-fmla.py b/tablib/packages/xlwt/examples/parse-fmla.py deleted file mode 100644 index 81a8d00..0000000 --- a/tablib/packages/xlwt/examples/parse-fmla.py +++ /dev/null @@ -1,12 +0,0 @@ -from xlwt import ExcelFormulaParser, ExcelFormula
-import sys
-
-f = ExcelFormula.Formula(
-""" -((1.80 + 2.898 * 1)/(1.80 + 2.898))*
-AVERAGE((1.80 + 2.898 * 1)/(1.80 + 2.898);
- (1.80 + 2.898 * 1)/(1.80 + 2.898);
- (1.80 + 2.898 * 1)/(1.80 + 2.898)) +
-SIN(PI()/4)""")
-
-#for t in f.rpn():
-# print "%15s %15s" % (ExcelFormulaParser.PtgNames[t[0]], t[1])
diff --git a/tablib/packages/xlwt/examples/protection.py b/tablib/packages/xlwt/examples/protection.py deleted file mode 100644 index 6cf24f9..0000000 --- a/tablib/packages/xlwt/examples/protection.py +++ /dev/null @@ -1,134 +0,0 @@ -# Copyright (C) 2005 Kiseliov Roman
-
-from xlwt import *
-
-fnt = Font()
-fnt.name = 'Arial'
-fnt.colour_index = 4
-fnt.bold = True
-
-borders = Borders()
-borders.left = 6
-borders.right = 6
-borders.top = 6
-borders.bottom = 6
-
-style = XFStyle()
-style.font = fnt
-style.borders = borders
-
-wb = Workbook()
-
-ws0 = wb.add_sheet('Rows Outline')
-
-ws0.write_merge(1, 1, 1, 5, 'test 1', style)
-ws0.write_merge(2, 2, 1, 4, 'test 1', style)
-ws0.write_merge(3, 3, 1, 3, 'test 2', style)
-ws0.write_merge(4, 4, 1, 4, 'test 1', style)
-ws0.write_merge(5, 5, 1, 4, 'test 3', style)
-ws0.write_merge(6, 6, 1, 5, 'test 1', style)
-ws0.write_merge(7, 7, 1, 5, 'test 4', style)
-ws0.write_merge(8, 8, 1, 4, 'test 1', style)
-ws0.write_merge(9, 9, 1, 3, 'test 5', style)
-
-ws0.row(1).level = 1
-ws0.row(2).level = 1
-ws0.row(3).level = 2
-ws0.row(4).level = 2
-ws0.row(5).level = 2
-ws0.row(6).level = 2
-ws0.row(7).level = 2
-ws0.row(8).level = 1
-ws0.row(9).level = 1
-
-
-ws1 = wb.add_sheet('Columns Outline')
-
-ws1.write_merge(1, 1, 1, 5, 'test 1', style)
-ws1.write_merge(2, 2, 1, 4, 'test 1', style)
-ws1.write_merge(3, 3, 1, 3, 'test 2', style)
-ws1.write_merge(4, 4, 1, 4, 'test 1', style)
-ws1.write_merge(5, 5, 1, 4, 'test 3', style)
-ws1.write_merge(6, 6, 1, 5, 'test 1', style)
-ws1.write_merge(7, 7, 1, 5, 'test 4', style)
-ws1.write_merge(8, 8, 1, 4, 'test 1', style)
-ws1.write_merge(9, 9, 1, 3, 'test 5', style)
-
-ws1.col(1).level = 1
-ws1.col(2).level = 1
-ws1.col(3).level = 2
-ws1.col(4).level = 2
-ws1.col(5).level = 2
-ws1.col(6).level = 2
-ws1.col(7).level = 2
-ws1.col(8).level = 1
-ws1.col(9).level = 1
-
-
-ws2 = wb.add_sheet('Rows and Columns Outline')
-
-ws2.write_merge(1, 1, 1, 5, 'test 1', style)
-ws2.write_merge(2, 2, 1, 4, 'test 1', style)
-ws2.write_merge(3, 3, 1, 3, 'test 2', style)
-ws2.write_merge(4, 4, 1, 4, 'test 1', style)
-ws2.write_merge(5, 5, 1, 4, 'test 3', style)
-ws2.write_merge(6, 6, 1, 5, 'test 1', style)
-ws2.write_merge(7, 7, 1, 5, 'test 4', style)
-ws2.write_merge(8, 8, 1, 4, 'test 1', style)
-ws2.write_merge(9, 9, 1, 3, 'test 5', style)
-
-ws2.row(1).level = 1
-ws2.row(2).level = 1
-ws2.row(3).level = 2
-ws2.row(4).level = 2
-ws2.row(5).level = 2
-ws2.row(6).level = 2
-ws2.row(7).level = 2
-ws2.row(8).level = 1
-ws2.row(9).level = 1
-
-ws2.write_merge(3, 3, 1, 3, 'test 2', style)
-if 0:
- ws2.write_merge(1, 1, 1, 5, 'test 1', style)
- ws2.write_merge(2, 2, 1, 4, 'test 1', style)
- ws2.write_merge(3, 3, 1, 3, 'test 2', style)
- ws2.write_merge(4, 4, 1, 4, 'test 1', style)
- ws2.write_merge(5, 5, 1, 4, 'test 3', style)
- ws2.write_merge(6, 6, 1, 5, 'test 1', style)
- ws2.write_merge(7, 7, 1, 5, 'test 4', style)
- ws2.write_merge(8, 8, 1, 4, 'test 1', style)
- ws2.write_merge(9, 9, 1, 3, 'test 5', style)
-
-ws2.col(1).level = 1
-ws2.col(2).level = 1
-ws2.col(3).level = 2
-ws2.col(4).level = 2
-ws2.col(5).level = 2
-ws2.col(6).level = 2
-ws2.col(7).level = 2
-ws2.col(8).level = 1
-ws2.col(9).level = 1
-
-if 0:
- ws0.protect = True
- ws0.wnd_protect = True
- ws0.obj_protect = True
- ws0.scen_protect = True
- ws0.password = "123456"
-
- ws1.protect = True
- ws1.wnd_protect = True
- ws1.obj_protect = True
- ws1.scen_protect = True
- ws1.password = "abcdefghij"
-
- ws2.protect = True
- ws2.wnd_protect = True
- ws2.obj_protect = True
- ws2.scen_protect = True
- ws2.password = "ok"
-
- wb.protect = True
- wb.wnd_protect = True
- wb.obj_protect = True
-wb.save('protection.xls')
diff --git a/tablib/packages/xlwt/examples/python.bmp b/tablib/packages/xlwt/examples/python.bmp Binary files differdeleted file mode 100644 index bd1ba3f..0000000 --- a/tablib/packages/xlwt/examples/python.bmp +++ /dev/null diff --git a/tablib/packages/xlwt/examples/row_styles.py b/tablib/packages/xlwt/examples/row_styles.py deleted file mode 100644 index 14eb93b..0000000 --- a/tablib/packages/xlwt/examples/row_styles.py +++ /dev/null @@ -1,17 +0,0 @@ -#!/usr/bin/env python
-# -*- coding: windows-1251 -*-
-# Copyright (C) 2005 Kiseliov Roman
-
-from xlwt import *
-
-w = Workbook()
-ws = w.add_sheet('Hey, Dude')
-
-for i in range(6, 80):
- fnt = Font()
- fnt.height = i*20
- style = XFStyle()
- style.font = fnt
- ws.write(i, 1, 'Test')
- ws.row(i).set_style(style)
-w.save('row_styles.xls')
diff --git a/tablib/packages/xlwt/examples/row_styles_empty.py b/tablib/packages/xlwt/examples/row_styles_empty.py deleted file mode 100644 index 7bf5884..0000000 --- a/tablib/packages/xlwt/examples/row_styles_empty.py +++ /dev/null @@ -1,18 +0,0 @@ -#!/usr/bin/env python
-# -*- coding: windows-1251 -*-
-# Copyright (C) 2005 Kiseliov Roman
-__rev_id__ = """$Id: row_styles_empty.py 3309 2008-03-14 11:04:30Z chris $"""
-
-
-from pyExcelerator import *
-
-w = Workbook()
-ws = w.add_sheet('Hey, Dude')
-
-for i in range(6, 80):
- fnt = Font()
- fnt.height = i*20
- style = XFStyle()
- style.font = fnt
- ws.row(i).set_style(style)
-w.save('row_styles_empty.xls')
diff --git a/tablib/packages/xlwt/examples/simple.py b/tablib/packages/xlwt/examples/simple.py deleted file mode 100644 index a96f502..0000000 --- a/tablib/packages/xlwt/examples/simple.py +++ /dev/null @@ -1,24 +0,0 @@ -import xlwt
-from datetime import datetime
-
-font0 = xlwt.Font()
-font0.name = 'Times New Roman'
-font0.colour_index = 2
-font0.bold = True
-
-style0 = xlwt.XFStyle()
-style0.font = font0
-
-style1 = xlwt.XFStyle()
-style1.num_format_str = 'D-MMM-YY'
-
-wb = xlwt.Workbook()
-ws = wb.add_sheet('A Test Sheet')
-
-ws.write(0, 0, 'Test', style0)
-ws.write(1, 0, datetime.now(), style1)
-ws.write(2, 0, 1)
-ws.write(2, 1, 1)
-ws.write(2, 2, xlwt.Formula("A3+B3"))
-
-wb.save('example.xls')
diff --git a/tablib/packages/xlwt/examples/sst.py b/tablib/packages/xlwt/examples/sst.py deleted file mode 100644 index 8f30b19..0000000 --- a/tablib/packages/xlwt/examples/sst.py +++ /dev/null @@ -1,52 +0,0 @@ -#!/usr/bin/env python
-# -*- coding: windows-1251 -*-
-# Copyright (C) 2005 Kiseliov Roman
-
-from xlwt import *
-
-font0 = Formatting.Font()
-font0.name = 'Arial'
-font1 = Formatting.Font()
-font1.name = 'Arial Cyr'
-font2 = Formatting.Font()
-font2.name = 'Times New Roman'
-font3 = Formatting.Font()
-font3.name = 'Courier New Cyr'
-
-num_format0 = '0.00000'
-num_format1 = '0.000000'
-num_format2 = '0.0000000'
-num_format3 = '0.00000000'
-
-st0 = XFStyle()
-st1 = XFStyle()
-st2 = XFStyle()
-st3 = XFStyle()
-st4 = XFStyle()
-
-st0.font = font0
-st0.num_format = num_format0
-
-st1.font = font1
-st1.num_format = num_format1
-
-st2.font = font2
-st2.num_format = num_format2
-
-st3.font = font3
-st3.num_format = num_format3
-
-wb = Workbook()
-
-wb.add_style(st0)
-wb.add_style(st1)
-wb.add_style(st2)
-wb.add_style(st3)
-
-ws0 = wb.add_sheet('0')
-ws0.write(0, 0, 'Olya'*0x4000, st0)
-
-#for i in range(0, 0x10):
-# ws0.write(i, 2, ('%d'%i)*0x4000, st1)
-
-wb.save('sst.xls')
diff --git a/tablib/packages/xlwt/examples/unicode0.py b/tablib/packages/xlwt/examples/unicode0.py deleted file mode 100644 index 0f62a61..0000000 --- a/tablib/packages/xlwt/examples/unicode0.py +++ /dev/null @@ -1,12 +0,0 @@ -#!/usr/bin/env python
-import xlwt
-
-# Strings passed to (for example) Worksheet.write can be unicode objects,
-# or str (8-bit) objects, which are then decoded into unicode.
-# The encoding to be used defaults to 'ascii'. This can be overridden
-# when the Workbook instance is created:
-
-book = xlwt.Workbook(encoding='cp1251')
-sheet = book.add_sheet('cp1251-demo')
-sheet.write(0, 0, '\xce\xeb\xff')
-book.save('unicode0.xls')
diff --git a/tablib/packages/xlwt/examples/unicode1.py b/tablib/packages/xlwt/examples/unicode1.py deleted file mode 100644 index 51051a1..0000000 --- a/tablib/packages/xlwt/examples/unicode1.py +++ /dev/null @@ -1,28 +0,0 @@ -#!/usr/bin/env python
-# -*- coding: windows-1251 -*-
-# Copyright (C) 2005 Kiseliov Roman
-
-from xlwt import *
-
-w = Workbook()
-ws1 = w.add_sheet(u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK SMALL LETTER BETA}\N{GREEK SMALL LETTER GAMMA}')
-
-ws1.write(0, 0, u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK SMALL LETTER BETA}\N{GREEK SMALL LETTER GAMMA}')
-ws1.write(1, 1, u'\N{GREEK SMALL LETTER DELTA}x = 1 + \N{GREEK SMALL LETTER DELTA}')
-
-ws1.write(2,0, u'A\u2262\u0391.') # RFC2152 example
-ws1.write(3,0, u'Hi Mom -\u263a-!') # RFC2152 example
-ws1.write(4,0, u'\u65E5\u672C\u8A9E') # RFC2152 example
-ws1.write(5,0, u'Item 3 is \u00a31.') # RFC2152 example
-ws1.write(8,0, u'\N{INTEGRAL}') # RFC2152 example
-
-w.add_sheet(u'A\u2262\u0391.') # RFC2152 example
-w.add_sheet(u'Hi Mom -\u263a-!') # RFC2152 example
-one_more_ws = w.add_sheet(u'\u65E5\u672C\u8A9E') # RFC2152 example
-w.add_sheet(u'Item 3 is \u00a31.') # RFC2152 example
-
-one_more_ws.write(0, 0, u'\u2665\u2665')
-
-w.add_sheet(u'\N{GREEK SMALL LETTER ETA WITH TONOS}')
-w.save('unicode1.xls')
-
diff --git a/tablib/packages/xlwt/examples/unicode2.py b/tablib/packages/xlwt/examples/unicode2.py deleted file mode 100644 index 4ccaed1..0000000 --- a/tablib/packages/xlwt/examples/unicode2.py +++ /dev/null @@ -1,19 +0,0 @@ -#!/usr/bin/env python
-# -*- coding: windows-1251 -*-
-# Copyright (C) 2005 Kiseliov Roman
-
-from xlwt import *
-
-w = Workbook()
-ws1 = w.add_sheet(u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK SMALL LETTER BETA}\N{GREEK SMALL LETTER GAMMA}\u2665\u041e\u041b\u042f\u2665')
-
-fnt = Font()
-fnt.height = 26*20
-style = XFStyle()
-style.font = fnt
-
-for i in range(0x10000):
- ws1.write(i/0x10, i%0x10, unichr(i), style)
-
-w.save('unicode2.xls')
-
diff --git a/tablib/packages/xlwt/examples/wsprops.py b/tablib/packages/xlwt/examples/wsprops.py deleted file mode 100644 index e63c6c5..0000000 --- a/tablib/packages/xlwt/examples/wsprops.py +++ /dev/null @@ -1,155 +0,0 @@ -props = \
-[
- 'name',
- 'parent',
- 'rows',
- 'cols',
- 'merged_ranges',
- 'bmp_rec',
- 'show_formulas',
- 'show_grid',
- 'show_headers',
- 'panes_frozen',
- 'show_empty_as_zero',
- 'auto_colour_grid',
- 'cols_right_to_left',
- 'show_outline',
- 'remove_splits',
- 'selected',
- 'hidden',
- 'page_preview',
- 'first_visible_row',
- 'first_visible_col',
- 'grid_colour',
- 'preview_magn',
- 'normal_magn',
- 'row_gut_width',
- 'col_gut_height',
- 'show_auto_page_breaks',
- 'dialogue_sheet',
- 'auto_style_outline',
- 'outline_below',
- 'outline_right',
- 'fit_num_pages',
- 'show_row_outline',
- 'show_col_outline',
- 'alt_expr_eval',
- 'alt_formula_entries',
- 'row_default_height',
- 'col_default_width',
- 'calc_mode',
- 'calc_count',
- 'RC_ref_mode',
- 'iterations_on',
- 'delta',
- 'save_recalc',
- 'print_headers',
- 'print_grid',
- 'grid_set',
- 'vert_page_breaks',
- 'horz_page_breaks',
- 'header_str',
- 'footer_str',
- 'print_centered_vert',
- 'print_centered_horz',
- 'left_margin',
- 'right_margin',
- 'top_margin',
- 'bottom_margin',
- 'paper_size_code',
- 'print_scaling',
- 'start_page_number',
- 'fit_width_to_pages',
- 'fit_height_to_pages',
- 'print_in_rows',
- 'portrait',
- 'print_not_colour',
- 'print_draft',
- 'print_notes',
- 'print_notes_at_end',
- 'print_omit_errors',
- 'print_hres',
- 'print_vres',
- 'header_margin',
- 'footer_margin',
- 'copies_num',
-]
-
-from xlwt import *
-
-wb = Workbook()
-ws = wb.add_sheet('sheet')
-
-print ws.name
-print ws.parent
-print ws.rows
-print ws.cols
-print ws.merged_ranges
-print ws.bmp_rec
-print ws.show_formulas
-print ws.show_grid
-print ws.show_headers
-print ws.panes_frozen
-print ws.show_empty_as_zero
-print ws.auto_colour_grid
-print ws.cols_right_to_left
-print ws.show_outline
-print ws.remove_splits
-print ws.selected
-# print ws.hidden
-print ws.page_preview
-print ws.first_visible_row
-print ws.first_visible_col
-print ws.grid_colour
-print ws.preview_magn
-print ws.normal_magn
-#print ws.row_gut_width
-#print ws.col_gut_height
-print ws.show_auto_page_breaks
-print ws.dialogue_sheet
-print ws.auto_style_outline
-print ws.outline_below
-print ws.outline_right
-print ws.fit_num_pages
-print ws.show_row_outline
-print ws.show_col_outline
-print ws.alt_expr_eval
-print ws.alt_formula_entries
-print ws.row_default_height
-print ws.col_default_width
-print ws.calc_mode
-print ws.calc_count
-print ws.RC_ref_mode
-print ws.iterations_on
-print ws.delta
-print ws.save_recalc
-print ws.print_headers
-print ws.print_grid
-#print ws.grid_set
-print ws.vert_page_breaks
-print ws.horz_page_breaks
-print ws.header_str
-print ws.footer_str
-print ws.print_centered_vert
-print ws.print_centered_horz
-print ws.left_margin
-print ws.right_margin
-print ws.top_margin
-print ws.bottom_margin
-print ws.paper_size_code
-print ws.print_scaling
-print ws.start_page_number
-print ws.fit_width_to_pages
-print ws.fit_height_to_pages
-print ws.print_in_rows
-print ws.portrait
-print ws.print_colour
-print ws.print_draft
-print ws.print_notes
-print ws.print_notes_at_end
-print ws.print_omit_errors
-print ws.print_hres
-print ws.print_vres
-print ws.header_margin
-print ws.footer_margin
-print ws.copies_num
diff --git a/tablib/packages/xlwt/examples/xlwt_easyxf_simple_demo.py b/tablib/packages/xlwt/examples/xlwt_easyxf_simple_demo.py deleted file mode 100644 index b4ff003..0000000 --- a/tablib/packages/xlwt/examples/xlwt_easyxf_simple_demo.py +++ /dev/null @@ -1,46 +0,0 @@ -
-# Write an XLS file with a single worksheet, containing
-# a heading row and some rows of data.
-
-import xlwt
-import datetime
-ezxf = xlwt.easyxf
-
-def write_xls(file_name, sheet_name, headings, data, heading_xf, data_xfs):
- book = xlwt.Workbook()
- sheet = book.add_sheet(sheet_name)
- rowx = 0
- for colx, value in enumerate(headings):
- sheet.write(rowx, colx, value, heading_xf)
- sheet.set_panes_frozen(True) # frozen headings instead of split panes
- sheet.set_horz_split_pos(rowx+1) # in general, freeze after last heading row
- sheet.set_remove_splits(True) # if user does unfreeze, don't leave a split there
- for row in data:
- rowx += 1
- for colx, value in enumerate(row):
- sheet.write(rowx, colx, value, data_xfs[colx])
- book.save(file_name)
-
-if __name__ == '__main__':
- import sys
- mkd = datetime.date
- hdngs = ['Date', 'Stock Code', 'Quantity', 'Unit Price', 'Value', 'Message']
- kinds = 'date text int price money text'.split()
- data = [
- [mkd(2007, 7, 1), 'ABC', 1000, 1.234567, 1234.57, ''],
- [mkd(2007, 12, 31), 'XYZ', -100, 4.654321, -465.43, 'Goods returned'],
- ] + [
- [mkd(2008, 6, 30), 'PQRCD', 100, 2.345678, 234.57, ''],
- ] * 100
-
- heading_xf = ezxf('font: bold on; align: wrap on, vert centre, horiz center')
- kind_to_xf_map = {
- 'date': ezxf(num_format_str='yyyy-mm-dd'),
- 'int': ezxf(num_format_str='#,##0'),
- 'money': ezxf('font: italic on; pattern: pattern solid, fore-colour grey25',
- num_format_str='$#,##0.00'),
- 'price': ezxf(num_format_str='#0.000000'),
- 'text': ezxf(),
- }
- data_xfs = [kind_to_xf_map[k] for k in kinds]
- write_xls('xlwt_easyxf_simple_demo.xls', 'Demo', hdngs, data, heading_xf, data_xfs)
diff --git a/tablib/packages/xlwt/excel-formula.g b/tablib/packages/xlwt/excel-formula.g deleted file mode 100644 index d10daa9..0000000 --- a/tablib/packages/xlwt/excel-formula.g +++ /dev/null @@ -1,374 +0,0 @@ -header {
- import struct
- import Utils
- from UnicodeUtils import upack1
- from ExcelMagic import *
-
- _RVAdelta = {"R": 0, "V": 0x20, "A": 0x40}
- _RVAdeltaRef = {"R": 0, "V": 0x20, "A": 0x40, "D": 0x20}
- _RVAdeltaArea = {"R": 0, "V": 0x20, "A": 0x40, "D": 0}
-
-
- class FormulaParseException(Exception):
- """
- An exception indicating that a Formula could not be successfully parsed.
- """
-}
-
-header "ExcelFormulaParser.__init__" {
- self.rpn = ""
- self.sheet_references = []
- self.xcall_references = []
-}
-
-options {
- language = "Python";
-}
-
-class ExcelFormulaParser extends Parser;
-options {
- k = 2;
- defaultErrorHandler = false;
- buildAST = false;
-}
-
-
-tokens {
- TRUE_CONST;
- FALSE_CONST;
- STR_CONST;
- NUM_CONST;
- INT_CONST;
-
- FUNC_IF;
- FUNC_CHOOSE;
- NAME;
- QUOTENAME;
-
- EQ;
- NE;
- GT;
- LT;
- GE;
- LE;
-
- ADD;
- SUB;
- MUL;
- DIV;
-
- POWER;
- PERCENT;
-
- LP;
- RP;
-
- LB;
- RB;
-
- COLON;
- COMMA;
- SEMICOLON;
- REF2D;
- REF2D_R1C1;
- BANG;
-}
-
-formula
- : expr["V"]
- ;
-
-expr[arg_type]
- : // {print "\n**expr %s" % arg_type}
- prec0_expr[arg_type]
- (
- (
- EQ { op = struct.pack('B', ptgEQ) }
- | NE { op = struct.pack('B', ptgNE) }
- | GT { op = struct.pack('B', ptgGT) }
- | LT { op = struct.pack('B', ptgLT) }
- | GE { op = struct.pack('B', ptgGE) }
- | LE { op = struct.pack('B', ptgLE) }
- )
- prec0_expr[arg_type] { self.rpn += op }
- )*
- ;
-
-prec0_expr[arg_type]
- : prec1_expr[arg_type]
- (
- (
- CONCAT { op = struct.pack('B', ptgConcat) }
- )
- prec1_expr[arg_type] { self.rpn += op }
- )*
- ;
-
-prec1_expr[arg_type]
- : // {print "**prec1_expr1 %s" % arg_type}
- prec2_expr[arg_type]
- // {print "**prec1_expr2 %s" % arg_type}
- (
- (
- ADD { op = struct.pack('B', ptgAdd) }
- | SUB { op = struct.pack('B', ptgSub) }
- )
- // {print "**prec1_expr3 %s" % arg_type}
- prec2_expr[arg_type]
- { self.rpn += op;
- // print "**prec1_expr4 %s" % arg_type
- }
- )*
- ;
-
-
-prec2_expr[arg_type]
- : prec3_expr[arg_type]
- (
- (
- MUL { op = struct.pack('B', ptgMul) }
- | DIV { op = struct.pack('B', ptgDiv) }
- )
- prec3_expr[arg_type] { self.rpn += op }
- )*
- ;
-
-prec3_expr[arg_type]
- : prec4_expr[arg_type]
- (
- (
- POWER { op = struct.pack('B', ptgPower) }
- )
- prec4_expr[arg_type] { self.rpn += op }
- )*
- ;
-
-prec4_expr[arg_type]
- : prec5_expr[arg_type]
- (
- PERCENT { self.rpn += struct.pack('B', ptgPercent) }
- )?
- ;
-
-prec5_expr[arg_type]
- : primary[arg_type]
- | SUB primary[arg_type] { self.rpn += struct.pack('B', ptgUminus) }
- ;
-
-primary[arg_type]
- : TRUE_CONST
- {
- self.rpn += struct.pack("2B", ptgBool, 1)
- }
- | FALSE_CONST
- {
- self.rpn += struct.pack("2B", ptgBool, 0)
- }
- | str_tok:STR_CONST
- {
- self.rpn += struct.pack("B", ptgStr) + upack1(str_tok.text[1:-1].replace("\"\"", "\""))
- }
- | int_tok:INT_CONST
- {
- // print "**int_const", int_tok.text
- int_value = int(int_tok.text)
- if int_value <= 65535:
- self.rpn += struct.pack("<BH", ptgInt, int_value)
- else:
- self.rpn += struct.pack("<Bd", ptgNum, float(int_value))
- }
- | num_tok:NUM_CONST
- {
- self.rpn += struct.pack("<Bd", ptgNum, float(num_tok.text))
- }
- | ref2d_tok:REF2D
- {
- // print "**ref2d %s %s" % (ref2d_tok.text, arg_type)
- r, c = Utils.cell_to_packed_rowcol(ref2d_tok.text)
- ptg = ptgRefR + _RVAdeltaRef[arg_type]
- self.rpn += struct.pack("<B2H", ptg, r, c)
- }
- | ref2d1_tok:REF2D COLON ref2d2_tok:REF2D
- {
- r1, c1 = Utils.cell_to_packed_rowcol(ref2d1_tok.text)
- r2, c2 = Utils.cell_to_packed_rowcol(ref2d2_tok.text)
- ptg = ptgAreaR + _RVAdeltaArea[arg_type]
- self.rpn += struct.pack("<B4H", ptg, r1, r2, c1, c2)
- }
- | sheet1 = sheet
- {
- sheet2 = sheet1
- }
- ( COLON sheet2 = sheet )? BANG ref3d_ref2d: REF2D
- {
- ptg = ptgRef3dR + _RVAdeltaRef[arg_type]
- rpn_ref2d = ""
- r1, c1 = Utils.cell_to_packed_rowcol(ref3d_ref2d.text)
- rpn_ref2d = struct.pack("<3H", 0x0000, r1, c1)
- }
- ( COLON ref3d_ref2d2: REF2D
- {
- ptg = ptgArea3dR + _RVAdeltaArea[arg_type]
- r2, c2 = Utils.cell_to_packed_rowcol(ref3d_ref2d2.text)
- rpn_ref2d = struct.pack("<5H", 0x0000, r1, r2, c1, c2)
- }
- )?
- {
- self.rpn += struct.pack("<B", ptg)
- self.sheet_references.append((sheet1, sheet2, len(self.rpn)))
- self.rpn += rpn_ref2d
- }
- | FUNC_IF
- LP expr["V"] (SEMICOLON | COMMA)
- {
- self.rpn += struct.pack("<BBH", ptgAttr, 0x02, 0) // tAttrIf
- pos0 = len(self.rpn) - 2
- }
- expr[arg_type] (SEMICOLON | COMMA)
- {
- self.rpn += struct.pack("<BBH", ptgAttr, 0x08, 0) // tAttrSkip
- pos1 = len(self.rpn) - 2
- self.rpn = self.rpn[:pos0] + struct.pack("<H", pos1-pos0) + self.rpn[pos0+2:]
- }
- expr[arg_type] RP
- {
- self.rpn += struct.pack("<BBH", ptgAttr, 0x08, 3) // tAttrSkip
- self.rpn += struct.pack("<BBH", ptgFuncVarR, 3, 1) // 3 = nargs, 1 = IF func
- pos2 = len(self.rpn)
- self.rpn = self.rpn[:pos1] + struct.pack("<H", pos2-(pos1+2)-1) + self.rpn[pos1+2:]
- }
- | FUNC_CHOOSE
- {
- arg_type = "R"
- rpn_chunks = []
- }
- LP expr["V"] // first argument (the selector)
- {
- rpn_start = len(self.rpn)
- ref_markers = [len(self.sheet_references)]
- }
- (
- (SEMICOLON | COMMA)
- { mark = len(self.rpn) }
- (
- expr[arg_type]
- | { self.rpn += struct.pack("B", ptgMissArg) }
- )
- {
- rpn_chunks.append(self.rpn[mark:])
- ref_markers.append(len(self.sheet_references))
- }
- )*
- RP
- {
- self.rpn = self.rpn[:rpn_start]
- nc = len(rpn_chunks)
- chunklens = [len(chunk) for chunk in rpn_chunks]
- skiplens = [0] * nc
- skiplens[-1] = 3
- for ic in xrange(nc-1, 0, -1):
- skiplens[ic-1] = skiplens[ic] + chunklens[ic] + 4
- jump_pos = [2 * nc + 2]
- for ic in xrange(nc):
- jump_pos.append(jump_pos[-1] + chunklens[ic] + 4)
- chunk_shift = 2 * nc + 6 // size of tAttrChoose
- for ic in xrange(nc):
- for refx in xrange(ref_markers[ic], ref_markers[ic+1]):
- ref = self.sheet_references[refx]
- self.sheet_references[refx] = (ref[0], ref[1], ref[2] + chunk_shift)
- chunk_shift += 4 // size of tAttrSkip
- choose_rpn = []
- choose_rpn.append(struct.pack("<BBH", ptgAttr, 0x04, nc)) // 0x04 is tAttrChoose
- choose_rpn.append(struct.pack("<%dH" % (nc+1), *jump_pos))
- for ic in xrange(nc):
- choose_rpn.append(rpn_chunks[ic])
- choose_rpn.append(struct.pack("<BBH", ptgAttr, 0x08, skiplens[ic])) // 0x08 is tAttrSkip
- choose_rpn.append(struct.pack("<BBH", ptgFuncVarV, nc+1, 100)) // 100 is CHOOSE fn
- self.rpn += "".join(choose_rpn)
- }
- | name_tok:NAME
- {
- raise Exception("[formula] found unexpected NAME token (%r)" % name_tok.txt)
- // #### TODO: handle references to defined names here
- }
- | func_tok:NAME
- {
- func_toku = func_tok.text.upper()
- if func_toku in all_funcs_by_name:
- (opcode,
- min_argc,
- max_argc,
- func_type,
- arg_type_str) = all_funcs_by_name[func_toku]
- arg_type_list = list(arg_type_str)
- else:
- raise Exception("[formula] unknown function (%s)" % func_tok.text)
- // print "**func_tok1 %s %s" % (func_toku, func_type)
- xcall = opcode < 0
- if xcall:
- // The name of the add-in function is passed as the 1st arg
- // of the hidden XCALL function
- self.xcall_references.append((func_toku, len(self.rpn) + 1))
- self.rpn += struct.pack("<BHHH",
- ptgNameXR,
- 0xadde, // ##PATCHME## index to REF entry in EXTERNSHEET record
- 0xefbe, // ##PATCHME## one-based index to EXTERNNAME record
- 0x0000) // unused
- }
- LP arg_count = expr_list[arg_type_list, min_argc, max_argc] RP
- {
- if arg_count > max_argc or arg_count < min_argc:
- raise Exception, "%d parameters for function: %s" % (arg_count, func_tok.text)
- if xcall:
- func_ptg = ptgFuncVarR + _RVAdelta[func_type]
- self.rpn += struct.pack("<2BH", func_ptg, arg_count + 1, 255) // 255 is magic XCALL function
- elif min_argc == max_argc:
- func_ptg = ptgFuncR + _RVAdelta[func_type]
- self.rpn += struct.pack("<BH", func_ptg, opcode)
- elif arg_count == 1 and func_tok.text.upper() == "SUM":
- self.rpn += struct.pack("<BBH", ptgAttr, 0x10, 0) // tAttrSum
- else:
- func_ptg = ptgFuncVarR + _RVAdelta[func_type]
- self.rpn += struct.pack("<2BH", func_ptg, arg_count, opcode)
- }
- | LP expr[arg_type] RP
- {
- self.rpn += struct.pack("B", ptgParen)
- }
- ;
-
-expr_list[arg_type_list, min_argc, max_argc] returns [arg_cnt]
- {
- arg_cnt = 0
- arg_type = arg_type_list[arg_cnt]
- // print "**expr_list1[%d] req=%s" % (arg_cnt, arg_type)
- }
- : expr[arg_type] { arg_cnt += 1 }
- (
- {
- if arg_cnt < len(arg_type_list):
- arg_type = arg_type_list[arg_cnt]
- else:
- arg_type = arg_type_list[-1]
- if arg_type == "+":
- arg_type = arg_type_list[-2]
- // print "**expr_list2[%d] req=%s" % (arg_cnt, arg_type)
- }
- (SEMICOLON | COMMA)
- (
- expr[arg_type]
- | { self.rpn += struct.pack("B", ptgMissArg) }
- )
- { arg_cnt += 1 }
- )*
- |
- ;
-
-sheet returns[ref]
- : sheet_ref_name: NAME
- { ref = sheet_ref_name.text }
- | sheet_ref_int: INT_CONST
- { ref = sheet_ref_int.text }
- | sheet_ref_quote: QUOTENAME
- { ref = sheet_ref_quote.text[1:-1].replace("''", "'") }
- ;
|
