static LONG unpack_rle(unsigned char *src, LONG srclen, char *dst, LONG dstlen,
int bpp, int comp)
{
char *dst0 = dst;
unsigned char *srcn = src+srclen;
int bits=0, data=0;
if(!comp) {
if(srclen>dstlen)
srclen = dstlen;
memcpy(dst, src, srclen);
return srclen;
}
while(dstlen>0) {
int code;
GETBITS(code, 8);
if(code&0x80) {
char rpt;
GETBITS(rpt, bpp);
code -= 0x100;
if((dstlen-=(1-code))<0)
break;
do { *dst++ = rpt; } while(code++);
} else {
if((dstlen-=(code+1))<0)
break;
do GETBITS(*dst++, bpp); while(code--);
}
}
if(src != srcn)
fprintf(stderr, "Warning: Left %d bytes unused.\n", srcn-src);
return dst-dst0;
}
INLINE USHORT decode_p(void){
USHORT i, j, m;
j = pt_table[GETBITS(8)];
if (j < np) {
DROPBITS(pt_len[j]);
} else {
DROPBITS(8);
i = GETBITS(16);
m = 0x8000;
do {
if (i & m) j = right[j];
else j = left [j];
m >>= 1;
} while (j >= np);
DROPBITS(pt_len[j] - 8);
}
if (j != np-1) {
if (j > 0) {
j = (USHORT)(GETBITS(i=(USHORT)(j-1)) | (1U << (j-1)));
DROPBITS(i);
}
lastlen=j;
}
return lastlen;
}
void DXFBdr::load(CFRecord& record)
{
_UINT32 flags;
record >> flags;
dgLeft = static_cast<unsigned char>(GETBITS(flags, 0, 3));
dgRight = static_cast<unsigned char>(GETBITS(flags, 4, 7));
dgTop = static_cast<unsigned char>(GETBITS(flags, 8, 11));
dgBottom = static_cast<unsigned char>(GETBITS(flags, 12, 15));
icvLeft = static_cast<unsigned char>(GETBITS(flags, 16, 22));
icvRight = static_cast<unsigned char>(GETBITS(flags, 23, 29));
bitDiagDown = GETBIT(flags, 30);
bitDiagUp = GETBIT(flags, 31);
record >> flags;
icvTop = static_cast<unsigned char>(GETBITS(flags, 0, 6));
icvBottom = static_cast<unsigned char>(GETBITS(flags, 7, 13));
icvDiag = static_cast<unsigned char>(GETBITS(flags, 14, 20));
dgDiag = static_cast<unsigned char>(GETBITS(flags, 21, 24));
}
void AutoFilter::readFields(CFRecord& record)
{
size_t pos_record = record.getRdPtr();
if (size == 0xffffffff) size = record.getDataSize() - pos_record;
if (size > 0)
{
bExist = true;
}
m_bAutoFilter12 = false;
unsigned short flags;
record >> iEntry >> flags;
wJoin = GETBITS(flags, 0, 1);
fSimple1 = GETBIT(flags, 2);
fSimple2 = GETBIT(flags, 3);
fTopN = GETBIT(flags, 4);
fTop = GETBIT(flags, 5); //top(1) or bottom(0)
fPercent = GETBIT(flags, 6);
wTopN = GETBITS(flags, 7, 15);
unsigned short _iEntry = iEntry;
unsigned char _wJoin = wJoin;
unsigned short _wTopN = wTopN;
if (fTopN != 1)
{
record >> doper1;
record >> doper2;
}
INLINE USHORT DecodePosition(void){
USHORT i, j, c;
i = GETBITS(8); DROPBITS(8);
c = (USHORT) (d_code[i] << 8);
j = d_len[i];
i = (USHORT) (((i << j) | GETBITS(j)) & 0xff); DROPBITS(j);
return (USHORT) (c | i) ;
}
void List12TableStyleClientInfo::load(CFRecord& record)
{
unsigned short flags;
record >> flags;
fFirstColumn = static_cast<unsigned char>(GETBITS(flags, 0, 1));
fLastColumn = static_cast<unsigned char>(GETBITS(flags, 1, 2));
fRowStripes = static_cast<unsigned char>(GETBITS(flags, 3, 4));
fColumnStripes = static_cast<unsigned char>(GETBITS(flags, 5, 6));
fDefaultStyle = static_cast<unsigned char>(GETBITS(flags, 9, 10));
record >> stListStyleName;
}
void BookExt::readFields(CFRecord& record)
{
FrtHeader header(rt_BookExt);
record >> header;
record >> cb;
_UINT32 flags;
if (record.loadAnyData(flags))
{
fDontAutoRecover = GETBIT(flags, 0);
fHidePivotList = GETBIT(flags, 1);
fFilterPrivacy = GETBIT(flags, 2);
fEmbedFactoids = GETBIT(flags, 3);
mdFactoidDisplay = GETBITS(flags, 4, 5);
fSavedDuringRecovery = GETBIT(flags, 6);
fCreatedViaMinimalSave = GETBIT(flags, 7);
fOpenedViaDataRecovery = GETBIT(flags, 8);
fOpenedViaSafeLoad = GETBIT(flags, 9);
}
else return;
if(cb > 20)
{
record >> grbit1;
}
void PtgMemNoMemN::load(CFRecord& record)
{
unsigned char rec_type;
record >> rec_type;
type1 = GETBITS(rec_type, 5, 6);
record >> cce;
}
void BookBool::readFields(CFRecord& record)
{
unsigned short flags;
record >> flags;
fNoSaveSup = GETBIT(flags, 0);
fHasEnvelope = GETBIT(flags, 2);
fEnvelopeVisible = GETBIT(flags, 3);
fEnvelopeInitDone = GETBIT(flags, 4);
unsigned char grUpdateLinks_num = GETBITS(flags, 5, 6);
switch(grUpdateLinks_num)
{
case 0:
grUpdateLinks = std::wstring (L"userSet");
break;
case 1:
grUpdateLinks = std::wstring (L"never");
break;
case 2:
grUpdateLinks = std::wstring (L"always");
break;
default:
throw;// EXCEPT::RT::WrongBiffRecord("Unsupported value of grUpdateLinks.", record.getTypeString());
}
fHideBorderUnselLists = GETBIT(flags, 8);
}
void SortData::readFields(CFRecord& record)
{
unsigned short flags;
record >> frtHeader >> flags;
fCol = GETBIT(flags, 0);
fCaseSensitive = GETBIT(flags, 1);
fAltMethod = GETBIT(flags, 2);
sfp = GETBITS(flags, 3, 5);
RFX rfx_orig;
record >> rfx_orig >> cconditions;
rfx = static_cast<std::wstring >(rfx_orig);
record >> idParent;
std::list<CFRecordPtr>& recs = continue_records[rt_ContinueFrt12];
while(!recs.empty())
{
record.appendRawData(recs.front()->getData() + 12, recs.front()->getDataSize() - 12);
recs.pop_front();
}
for(unsigned int i = 0; i < cconditions; ++i)
{
SortCond12Ptr sort_cond(new SortCond12);
record >> *sort_cond;
sortCond12Array.push_back(sort_cond);
}
}
UWORD32 ih264d_get_bits_h264(dec_bit_stream_t *ps_bitstrm, UWORD32 u4_num_bits)
{
UWORD32 u4_code = 0;
if(u4_num_bits)
GETBITS(u4_code, ps_bitstrm->u4_ofst, ps_bitstrm->pu4_buffer, u4_num_bits);
return (u4_code);
}
INLINE USHORT decode_c(void){
USHORT i, j, m;
j = c_table[GETBITS(12)];
if (j < N1) {
DROPBITS(c_len[j]);
} else {
DROPBITS(12);
i = GETBITS(16);
m = 0x8000;
do {
if (i & m) j = right[j];
else j = left [j];
m >>= 1;
} while (j >= N1);
DROPBITS(c_len[j] - 12);
}
return j;
}
static USHORT read_tree_p(void){
USHORT i,n;
n = GETBITS(5);
DROPBITS(5);
if (n>0){
for (i=0; i<n; i++) {
pt_len[i] = (UCHAR)GETBITS(4);
DROPBITS(4);
}
for (i=n; i<np; i++) pt_len[i] = 0;
if (make_table(np,pt_len,8,pt_table)) return 1;
} else {
n = GETBITS(5);
DROPBITS(5);
for (i=0; i<np; i++) pt_len[i] = 0;
for (i=0; i<256; i++) pt_table[i] = n;
}
return 0;
}
static USHORT read_tree_c(void){
USHORT i,n;
n = GETBITS(9);
DROPBITS(9);
if (n>0){
for (i=0; i<n; i++) {
c_len[i] = (UCHAR)GETBITS(5);
DROPBITS(5);
}
for (i=n; i<510; i++) c_len[i] = 0;
if (make_table(510,c_len,12,c_table)) return 1;
} else {
n = GETBITS(9);
DROPBITS(9);
for (i=0; i<510; i++) c_len[i] = 0;
for (i=0; i<4096; i++) c_table[i] = n;
}
return 0;
}
/* argument is the number of pixels left to end-of-line (bound on run length) */
int process_run_dec(int lineleft, int color)
{
int runlen = 0;
do {
register int temp, hits;
temp = zeroLUT[(byte)(~(reg >> 24))]; /* number of leading ones in the
input stream, up to 8 */
for ( hits = 1; hits<=temp; hits++ )
{
runlen += melcorder[color];
if ( runlen >= lineleft )
{ /* reached end-of-line */
if ( runlen==lineleft && melcstate[color] < MELCSTATES )
{
melclen[color] = J[++melcstate[color]];
melcorder[color] = (1L<<melclen[color]);
}
FILLBUFFER(hits); /* actual # of 1's consumed */
return lineleft;
}
if ( melcstate[color] < MELCSTATES )
{
melclen[color] = J[++melcstate[color]];
melcorder[color] = (1L<<melclen[color]);
}
}
if (temp != 8)
{
FILLBUFFER(temp + 1); /* consume the leading
0 of the remainder encoding */
break;
}
FILLBUFFER(8);
} while ( 1 );
/* read the length of the remainder */
if ( melclen[color] )
{
register int temp;
GETBITS(temp, melclen[color]); /*** GETBITS is a macro, not a function */
runlen += temp;
}
limit_reduce = melclen[color]+1;
/* adjust melcoder parameters */
if ( melcstate[color] )
{
melclen[color] = J[--melcstate[color]];
melcorder[color] = (1L<<melclen[color]);
}
return runlen;
}
void LbsDropData::load(CFRecord& record)
{
unsigned short flags;
record >> flags >> cLine >> dxMin >> str;
wStyle = GETBITS(flags, 0, 1);
fFiltered = GETBIT(flags, 3);
if(0 != (str.getStructSize() & 1))
{
record.skipNunBytes(1); // padding
}
}
void Feat11WSSListInfo::load(CFRecord& record)
{
_UINT32 flags1, reserved;
_UINT16 unused2;
unsigned char flags2;
record >> LCID >> cDec >> flags1 >> flags2 >> bDefaultType >> unused2;
switch(lfdt)
{
case 0x00000002://Number
case 0x00000006://Currency
rgbDV = BiffStructurePtr(new Xnum); break;
case 0x00000003://Boolean
rgbDV = BiffStructurePtr(new BIFF_DWORD); break;
case 0x00000004:
rgbDV = BiffStructurePtr(new DateAsNum); break;
case 0x00000005://Invalid
case 0x00000007://Invalid
case 0x00000009://Invalid
case 0x0000000a://Invalid
break;
case 0x00000001://Short Text
case 0x00000008://Choice
case 0x0000000b://Multi-choice
rgbDV = BiffStructurePtr(new XLUnicodeString); break;
}
if (rgbDV)
rgbDV->load(record);
record >> strFormula;
record >> reserved;
fPercent = GETBIT(flags1, 0);
fDecSet = GETBIT(flags1, 1);
fDateOnly = GETBIT(flags1, 2);
fReadingOrder = GETBITS(flags1, 3, 4);
fRichText = GETBIT(flags1, 5);
fUnkRTFormatting= GETBIT(flags1, 6);
fAlertUnkRTFormatting = GETBIT(flags1, 7);
fReadOnly = GETBIT(flags2, 0);
fRequired = GETBIT(flags2, 1);
fMinSet = GETBIT(flags2, 2);
fMaxSet = GETBIT(flags2, 3);
fDefaultSet = GETBIT(flags2, 4);
fDefaultDateToday = GETBIT(flags2, 5);
fLoadFormula = GETBIT(flags2, 6);
fAllowFillIn = GETBIT(flags2, 6);
}
void Text::readFields(CFRecord& record)
{
unsigned short flags1;
unsigned short flags2;
record >> at >> vat >> wBkgMode >> rgbText >> x >> y >> dx >> dy >> flags1;
if (record.getGlobalWorkbookInfo()->Version < 0x0600)
{
int orient = GETBITS(flags1, 8, 10);
switch(orient)
{
case 0: trot = 0; break; // Text orientation: not rotated.
case 1: trot = 0xff; break; // Text orientation: vertically stacked.
case 2: trot = 90; break; // Text orientation: 90 deg counterclockwise.
case 3: trot = 270; break; // Text orientation: 90 deg clockwise.
}
}
else
{
record >> icvText >> flags2 >> trot;
//icv -> from Palette
dlp = static_cast<unsigned char>(GETBITS(flags2, 0, 3));
iReadingOrder = static_cast<unsigned char>(GETBITS(flags2, 14, 15));
}
fAutoColor = GETBIT(flags1, 0);
fShowKey = GETBIT(flags1, 1);
fShowValue = GETBIT(flags1, 2);
fAutoText = GETBIT(flags1, 4);
fGenerated = GETBIT(flags1, 5);
fDeleted = GETBIT(flags1, 6);
fAutoMode = GETBIT(flags1, 7);
fShowLabelAndPerc = GETBIT(flags1, 11);
fShowPercent = GETBIT(flags1, 12);
fShowBubbleSizes = GETBIT(flags1, 13);
fShowLabel = GETBIT(flags1, 14);
}
void Row::readFields(CFRecord& record)
{
global_info_ = record.getGlobalWorkbookInfo();
record >> rw >> colMic >> colMac >> miyRw;
record.skipNunBytes(4); // reserved / unused
unsigned short flags;
record >> flags;
iOutLevel = GETBITS(flags, 0, 2);
fCollapsed = GETBIT(flags, 4);
fDyZero = GETBIT(flags, 5);
fUnsynced = GETBIT(flags, 6);
fGhostDirty = GETBIT(flags, 7);
record >> flags;
ixfe_val = GETBITS(flags, 0, 11);
fExAsc = GETBIT(flags, 12);
fExDes = GETBIT(flags, 13);
fPhonetic = GETBIT(flags, 14);
}
USHORT Unpack_QUICK(UCHAR *in, UCHAR *out, USHORT origsize){
USHORT i, j;
UCHAR *outend;
initbitbuf(in);
outend = out+origsize;
while (out < outend) {
if (GETBITS(1)!=0) {
DROPBITS(1);
*out++ = text[quick_text_loc++ & QBITMASK] = (UCHAR)GETBITS(8); DROPBITS(8);
} else {
DROPBITS(1);
j = (USHORT) (GETBITS(2)+2); DROPBITS(2);
i = (USHORT) (quick_text_loc - GETBITS(8) - 1); DROPBITS(8);
while(j--) {
*out++ = text[quick_text_loc++ & QBITMASK] = text[i++ & QBITMASK];
}
}
}
quick_text_loc = (USHORT)((quick_text_loc+5) & QBITMASK);
return 0;
}
INLINE USHORT DecodeChar(void){
USHORT c;
c = son[R];
/* travel from root to leaf, */
/* choosing the smaller child node (son[]) if the read bit is 0, */
/* the bigger (son[]+1} if 1 */
while (c < T) {
c = son[c + GETBITS(1)];
DROPBITS(1);
}
c -= T;
update(c);
return c;
}
void Qsir::readFields(CFRecord& record)
{
_UINT32 flags;
record >> frtRefHeaderU >> cbQsirSaved >> cbQsifSaved >> flags >> iSortCustom >> cQsif >> cpstDeleted >> idFieldNext >> ccolExtraLeft >> ccolExtraRight;
record >> idList >> rgbTitle;
fPersist = GETBIT(flags, 0);
fPersistSort = GETBIT(flags, 1);
fPersistAutoFilter = GETBIT(flags, 2);
fSorted = GETBIT(flags, 20);
fCaseSensSort = GETBIT(flags, 21);
fHdrRowSort = GETBIT(flags, 22);
fidWrapped = GETBIT(flags, 23);
fTitlesOld = GETBIT(flags, 25);
wVerBeforeRefreshAlert = GETBITS(flags, 26, 30);
}
void Qsif::readFields(CFRecord& record)
{
unsigned short flags1, flags2;
record >> frtHeaderOld >> flags1 >> flags2 >> idField;
fUserIns = GETBIT(flags1, 0);
fFillDown = GETBIT(flags1, 1);
fSortDes = GETBIT(flags1, 2);
iSortKey = GETBITS(flags1, 3, 10);
fRowNums = GETBIT(flags1, 11);
fSorted = GETBIT(flags1, 13);
fClipped = GETBIT(flags2, 0);
if (record.getRdPtr() >= record.getDataSize())
return;
record >> idList >> rgbTitle;
}
void GET_THEM(void)
{
p.d0.l = 1; // MOVEQ #1,D0 ; minimum fillbits
p.d5.l = 0; // MOVEQ #0,D5 ; value
LOOP:
p.carry = (p.d1.l & 0x80000000UL) != 0;
p.d1.l += p.d1.l; // ADD.L D1,D1 ; shift bit outside
if ( p.carry ) // BCC.S EINDE ; if '1' end decode
{
p.d5.w += p.d5.w;
p.d5.w ++; // ADDX.W D5,D5 ; value *2+1
p.d0.w ++; // ADDQ.W #1,D0 ; extra fill
p.d2.w ++; // ADDQ.W #1,D2 ; extra get
if ( p.a3.w != p.d0.w ) // CMP.W A3,D0 ; max bits
goto LOOP; // BNE.S LOOP ; nog mal
p.d0.w --; // SUBQ.W #1,D0 ; 1 bit less to trash
} // EINDE:
FILLBITS(); // BSR.S FILLBITS ; trash bits
p.d0.w = p.d2.w; // MOVE.W D2,D0 ; bits to get
GETBITS();
}
int asmgen_parse_value(struct ScanData *scanner,
struct SymTab **curSyms,
unsigned int *pResult) {
struct Token curToken;
unsigned int lval, rval;
/* scan next token or expression */
switch (get_token(&curToken, scanner)) {
case TOK_INT:
/* integer value, just pass it back */
DEBUG(1) printf("Got an integer - %d\n", curToken.value);
lval = curToken.value;
if (curToken.limHigh - curToken.limLow < 8*sizeof(lval) - 1) {
/* if token is specified with a bitslice, use only those bits */
lval = GETBITS(curToken.limLow, curToken.limHigh, lval);
}
*pResult = lval;
return 0;
break;
case TOK_IDENT:
/* identifier, locate it in the symbol table */
DEBUG(1) printf("Got a symbol lookup - '%s'\n", curToken.token);
if (symtab_lookup(curSyms, curToken.token, NULL, (int*)&lval) == 0) {
/* symbol table lookup success */
if (curToken.limHigh - curToken.limLow < 8*sizeof(lval) - 1) {
/* if token is specified with a bitslice, use only those bits */
lval = GETBITS(curToken.limLow, curToken.limHigh, lval);
}
*pResult = lval;
return 0;
}
printf("ERROR - Symbol '%s' Not Found\n", curToken.token);
break;
case TOK_LPAREN:
/* left parentheses, beginning of an arithmetic expression */
/* start by evaluating first term (may be another expression */
if (asmgen_parse_value(scanner, curSyms, &lval) != 0) {
/* error parsing sub-expression */
printf("ERROR - Cannot Parse Arithmetic Expression\n");
return -1;
}
/* inner loop to evalate left-to-right arithmetic expressions */
while (1) {
/* get next token */
switch (get_token(&curToken, scanner)) {
case TOK_RPAREN:
/* close parentheses, end of sub-expression */
*pResult = lval;
return 0;
break;
case TOK_ARITHOP:
/* arithmetic operation (+/-), get right hand value */
if (asmgen_parse_value(scanner, curSyms, &rval) != 0) {
/* error parsing sub-expression */
printf("ERROR - Cannot Parse Arithmetic Expression\n");
return -1;
}
/* handle arithmetic operation */
switch (curToken.token[0]) {
case '+':
lval += rval;
break;
case '-':
lval -= rval;
break;
default:
/* unhandled */
printf("ERROR - Unknown Arithmetic operation '%s'\n", curToken.token);
return -1;
break;
}
break;
default:
printf("ERROR - Unexpected token '%s' while parsing subexpression\n",
curToken.token);
return -1;
break;
}
}
break;
default:
/* unknown token */
printf("Unhandled token \'%s\'\n", curToken.token);
break;
}
return -1;
}
static int dec_rec2(struct in *in, struct dec_hufftbl *hu, int *runp, int c, int i)
{
LEBI_DCL;
LEBI_GET(in);
if (i)
{
UNGETBITS(in, i & 127);
*runp = i >> 8 & 15;
i >>= 16;
}
else
{
for (i = DECBITS;
(c = ((c << 1) | GETBITS(in, 1))) >= (hu->maxcode[i]); i++);
if (i >= 16)
{
in->marker = M_BADHUFF;
return 0;
}
i = hu->vals[hu->valptr[i] + c - hu->maxcode[i - 1] * 2];
*runp = i >> 4;
i &= 15;
}
if (i == 0)
{ /* sigh, 0xf0 is 11 bit */
LEBI_PUT(in);
return 0;
}
/* receive part */
int asmgen_assemble(struct SymTab **curSyms,
FILE *input,
char *data) {
struct ScanData cfgScan;
struct Token curToken;
struct ASMRecord *instr;
struct ASMRecord *asmcfg = NULL;
unsigned int argCount, fieldNum, value;
unsigned int offset = 0, outBits;
int x;
/* set up the scanner */
SCANNER_INIT(&cfgScan, input);
/* try to assemble this thing */
while (1) {
switch (get_token(&curToken, &cfgScan)) {
case TOK_EOF:
/* end of file, stop assembling */
return 0;
break;
case TOK_LABEL:
case TOK_ENDL:
/* ignore these tokens, just pass over */
break;
case TOK_DIRECTIVE:
/* directive, pass current data to directive handler */
directive_parse(&cfgScan, &curToken, NULL, &asmcfg, &offset);
break;
case TOK_IDENT:
/* assume this is a format entry */
DEBUG(1) printf("\nAssembling mnemonic %s\n", curToken.token);
/* find instruction layout */
for (instr = asmcfg; (instr!=NULL) &&
(strcmp(instr->mnemonic, curToken.token) != 0);
instr = instr->next) { }
/* shouldn't happen, but just in case */
if (instr == NULL) {
printf("ERROR - Unexpected instruction %s\n", curToken.token);
return -1;
}
/* got it, so start assembling */
DEBUG(1) printf("Found format for instruction %s, %d bytes\n",
curToken.token, instr->byte_count);
outBits = instr->asm_mask;
for (argCount=0; argCount<instr->num_args; argCount++) {
/* parse next token or parenthesized expression */
if (asmgen_parse_value(&cfgScan, curSyms, &value) != 0) {
fprintf(stderr, "ERROR - Argument %d bad, line %d\n",
argCount, curToken.linenum);
return -1;
}
if (CHECK_FIELD_TOO_SMALL(instr->arg_widths[argCount], value)) {
printf("WARNING - Value 0x%x not representable with %d bits, line %d\n",
value, instr->arg_widths[argCount], curToken.linenum);
}
/* token OK, fill in all fields using this */
for (fieldNum=0; instr->fmt_args[fieldNum].argNum > -1; fieldNum++) {
if (argCount == instr->fmt_args[fieldNum].argNum) {
DEBUG(1) printf("Field number %d uses arg %d (value 0x%x)\n",
fieldNum, argCount, value);
outBits |= GETBITS(0,instr->arg_widths[argCount], value)
<< instr->fmt_args[fieldNum].argOffset;
}
}
}
/* expect the newline at the end */
if (get_token(&curToken, &cfgScan) != TOK_ENDL) {
fprintf(stderr, "ERROR - Bad token %s at end of line %d\n",
curToken.token, curToken.linenum);
return -1;
}
/* fill in the assembled instruction into the data buffer */
DEBUG(1) printf("Outputting %d bytes\n", instr->byte_count);
for (x=(instr->byte_count-1); x>=0; x--) {
data[offset] = GETBITS(8*x,(8*x)+7, outBits);
DEBUG(1) printf("Assembled %02x\n", data[offset]);
offset += 1;
}
break;
default:
/* dunno, this is bad */
fprintf(stderr, "ERROR - Bad token %s at line %d\n",
curToken.token, curToken.linenum);
return -1;
break;
}
}
return 0;
}
static inline u32 is_timer_overflow_interrupt(int i)
{
return GETBITS(gptimer[i]->TISR, 1, 1);
}
void timer_init(void)
{
int i;
#ifdef USE_VMM
if(vmm_map_region(&l4wakeup_region) != OK) {
early_panic("Unable to map L4 wakeup registers.");
return;
}
if(vmm_map_region(&l4perip_region) != OK) {
early_panic("Unable to map L4 peripheral registers.");
return;
}
#ifdef OMAP3530
if(vmm_map_region(&l4core_region) != OK) {
early_panic("Unable to map L4 core registers.");
return;
}
#endif
#ifdef OMAP4460
if(vmm_map_region(&l4abe_region) != OK) {
early_panic("Unable to map L4 ABE registers.");
return;
}
#endif
#endif
#ifdef OMAP3530
/* For some reason, this is defaulting to SYS_CLK on my board, even
* though the manual says otherwise. Set it to 32K_FCLK, div-by-1. */
*CM_CLKSEL_WKUP = (*CM_CLKSEL_WKUP & (~0x7)) | 0x2;
#endif
#ifdef OMAP4460
DLOG(1, "CM_WKUP_GPTIMER1_CLKCTRL=%#x (%s)\n", *CM_WKUP_GPTIMER1_CLKCTRL, GETBITS(*CM_WKUP_GPTIMER1_CLKCTRL, 24, 1) ? "32kHz" : "SYS_CLK");
#endif
#ifdef OMAP4460
GBLTIMER = (void *) (arm_config_base_address() + 0x200);
PVTTIMER = (void *) (arm_config_base_address() + 0x600);
WATCHDOG = (void *) (arm_config_base_address() + 0x620);
#ifdef USE_VMM
timer_region.pstart = ((u32) PVTTIMER) & 0xFFF00000;
timer_region.vstart = (void *) (((u32) PVTTIMER) & 0xFFF00000);
/* ensure mapping of private/global timers */
if(vmm_map_region(&timer_region) != OK) {
early_panic("Unable to map private/global timers.");
return;
}
#endif
PVTTIMER->control = 0;
WATCHDOG->control = 0;
GBLTIMER->control = 0;
#endif
for(i=0;i<NUM_TIMERS;i++) {
intc_set_irq_handler(GPTIMER_BASE_IRQ + i, timer_irq_handler);
intc_unmask_irq(GPTIMER_BASE_IRQ + i);
DLOG(1, "gptimer[%d] revision=%#x TCLR=%#x\n", i+1, gptimer[i+1]->TIDR, gptimer[i+1]->TCLR);
}
/* OMAP4460 TRM p892 */
DLOG(1, "*CM_CLKMODE_DPLL_PER=%#x\n", *((u32 *) 0x4A008140));
/* OMAP4460 TRM p895 */
DLOG(1, "*CM_CLKSEL_DPLL_PER=%#x\n", *((u32 *) 0x4A00814C));
timing_loop();
}
#include <Binary/CFRecord.h>
namespace XLS
{
BiffStructurePtr CondFmtStructure::clone()
{
return BiffStructurePtr(new CondFmtStructure(*this));
}
void CondFmtStructure::load(CFRecord& record)
{
record >> ccf;
unsigned short flags;
record >> flags;
fToughRecalc = GETBIT(flags, 0);
nID = GETBITS(flags, 1, 15);
record >> refBound >> sqref;
}
const CellRef CondFmtStructure::getLocation() const
{
return sqref.getLocationFirstCell();
}
} // namespace XLS