[Top][All Lists]
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[Qemu-trivial] [PATCH 1/6] Add spelling exceptions for codespell
|
From: |
Stefan Weil |
|
Subject: |
[Qemu-trivial] [PATCH 1/6] Add spelling exceptions for codespell |
|
Date: |
Sat, 10 Dec 2011 00:19:41 +0100 |
This file can be used with codespell to suppress wrong
misspelling reports.
Signed-off-by: Stefan Weil <address@hidden>
---
scripts/codespell.exclude | 215 +++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 215 insertions(+), 0 deletions(-)
create mode 100644 scripts/codespell.exclude
diff --git a/scripts/codespell.exclude b/scripts/codespell.exclude
new file mode 100644
index 0000000..d69c946
--- /dev/null
+++ b/scripts/codespell.exclude
@@ -0,0 +1,215 @@
+ .rela.bss : { *(.rela.bss) }
+ .rela.bss : { *(.rela.bss) }
+ .rela.bss : { *(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*) }
+ *(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*)
+ *(.rela.ctors)
+ .rela.ctors : { *(.rela.ctors) }
+ .rela.ctors : { *(.rela.ctors) }
+ .rela.ctors : { *(.rela.ctors) }
+ .rela.data :
+ .rela.data : { *(.rela.data .rela.data.* .rela.gnu.linkonce.d.*) }
+ *(.rela.data .rela.data.* .rela.gnu.linkonce.d.*)
+ { *(.rela.data) *(.rela.gnu.linkonce.d*) }
+ .rela.data.rel.ro : { *(.rela.data.rel.ro* .rela.gnu.linkonce.d.rel.ro.*) }
+ *(.rela.dtors)
+ .rela.dtors : { *(.rela.dtors) }
+ .rela.dtors : { *(.rela.dtors) }
+ .rela.dtors : { *(.rela.dtors) }
+ .rela.dyn :
+ *(.rela.fini)
+ .rela.fini : { *(.rela.fini) }
+ .rela.fini : { *(.rela.fini) }
+ .rela.fini : { *(.rela.fini) }
+ *(.rela.got)
+ .rela.got1 : { *(.rela.got1) }
+ .rela.got2 : { *(.rela.got2) }
+ .rela.got : { *(.rela.got) }
+ .rela.got : { *(.rela.got) }
+ .rela.got : { *(.rela.got) }
+ .rela.IA_64.pltoff : { *(.rela.IA_64.pltoff) }
+ *(.rela.init)
+ .rela.init : { *(.rela.init) }
+ .rela.init : { *(.rela.init) }
+ .rela.init : { *(.rela.init) }
+ *(.rela.iplt)
+ *(.rela.opd)
+ *(.rela.plt)
+ .rela.plt :
+ .rela.plt : { *(.rela.plt) }
+ .rela.plt : { *(.rela.plt) }
+ .rela.plt : { *(.rela.plt) }
+ .rela.rodata :
+ { *(.rela.rodata) *(.rela.gnu.linkonce.r*) }
+ *(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
+ .rela.rodata : { *(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*) }
+ *(.rela.sbss2 .rela.sbss2.* .rela.gnu.linkonce.sb2.*)
+ .rela.sbss2 : { *(.rela.sbss2 .rela.sbss2.* .rela.gnu.linkonce.sb2.*) }
+ *(.rela.sbss .rela.sbss.* .rela.gnu.linkonce.sb.*)
+ .rela.sbss : { *(.rela.sbss .rela.sbss.* .rela.gnu.linkonce.sb.*) }
+ *(.rela.sdata2 .rela.sdata2.* .rela.gnu.linkonce.s2.*)
+ .rela.sdata2 : { *(.rela.sdata2 .rela.sdata2.* .rela.gnu.linkonce.s2.*) }
+ *(.rela.sdata .rela.sdata.* .rela.gnu.linkonce.s.*)
+ .rela.sdata : { *(.rela.sdata .rela.sdata.* .rela.gnu.linkonce.s.*) }
+ *(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*)
+ .rela.tbss : { *(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*) }
+ .rela.tbss : { *(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*) }
+ *(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*)
+ .rela.tdata : { *(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*) }
+ .rela.tdata : { *(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*) }
+ .rela.text :
+ { *(.rela.text) *(.rela.gnu.linkonce.t*) }
+ *(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
+ .rela.text : { *(.rela.text .rela.text.* .rela.gnu.linkonce.t.*) }
+ *(.rela.toc)
+ .rela.tocbss : { *(.rela.tocbss) }
+ aSign
+ aSign ?
+ aSign = 0;
+ aSign, aExp + 0x3C00, ( aSig | LIT64( 0x0010000000000000 ) )<<11 );
+ aSign, aExp, aSig, 0 STATUS_VAR );
+ aSign = extractFloat128Sign( a );
+ aSign = extractFloat128Sign( a );
+ aSign = extractFloat16Sign(a);
+ aSign = extractFloat32Sign(a);
+ aSign = extractFloat32Sign( a );
+ aSign = extractFloat32Sign( a );
+ aSign = extractFloat64Sign(a);
+ aSign = extractFloat64Sign( a );
+ aSign = extractFloat64Sign( a );
+ aSign = extractFloat ## s ## Sign(a); \
+ aSign = extractFloat ## s ## Sign( a ); \
+ aSign = extractFloatx80Sign( a );
+ aSign = extractFloatx80Sign( a );
+ aSign ? le128( b.high, b.low, a.high, a.low )
+ aSign ? LIT64( 0x8000000000000000 ) : LIT64( 0x3FF0000000000000 ));
+ aSign ? lt128( b.high, b.low, a.high, a.low )
+ aSign ? packFloat128( 1, 0, 0, 0 )
+ aSign ? packFloat128( 1, 0x3FFF, 0, 0 )
+ aSign ? packFloatx80( 1, 0, 0 )
+ flag aSign;
+ flag aSign, bSign;
+ flag aSign, bSign; \
+ flag aSign, bSign; \
+ flag aSign, bSign, cSign, zSign;
+ flag aSign, bSign, zSign;
+ flag aSign, zSign;
+ if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
+ if ( ( aExp == 0x7FF ) && aSig ) aSign = 0;
+ if ( ( aExp == 0x7FFF ) && ( aSig0 | aSig1 ) ) aSign = 0;
+ if ( ( aExp == 0x7FFF ) && aSig0 ) aSign = 0;
+ if ( ( aExp == 0x7FFF ) && (uint64_t) ( aSig<<1 ) ) aSign = 0;
+ if ( ( aExp == 0x7FFF ) && (uint64_t) ( aSig<<1 ) ) aSign = 0;
+ if ( ( aExp == 0xFF ) && aSig ) aSign = 0;
+ if ( ( aSig0 | aSig1 ) == 0 ) return packFloatx80( aSign, 0, 0 );
+ if ( aSig == 0 ) return packFloat128( aSign, 0, 0, 0 );
+ if ( aSig == 0 ) return packFloat64( aSign, 0, 0 );
+ if ( aSig == 0 ) return packFloatx80( aSign, 0, 0 );
+ if ( aSign ) {
+ if ( ! aSign
+ if ( ! aSign
+ if ( ! aSign || ( ( aExp == 0x7FFF ) && aSig ) ) {
+ if ( ! aSign || ( ( aExp == 0x7FFF ) && ( aSig0 | aSig1 ) ) ) {
+ if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
+ if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) {
+ if ( ! aSign || ( ( aExp == 0xFF ) && aSig ) ) return 0x7FFFFFFF;
+ if (aSign != bSign) { \
+ if ( aSign == bSign ) {
+ if ( aSign != bSign ) {
+ if ( aSign != bSign ) { \
+ if ( aSign != bSign ) return aSign || ( (uint32_t) ( ( av | bv )<<1 ) == 0
);
+ if ( aSign != bSign ) return aSign && ( (uint32_t) ( ( av | bv )<<1 ) != 0
);
+ if ( aSign != bSign ) return aSign || ( (uint64_t) ( ( av | bv )<<1 ) == 0
);
+ if ( aSign != bSign ) return aSign && ( (uint64_t) ( ( av | bv )<<1 ) != 0
);
+ if ( ! aSign ) return a;
+ if ( aSign ) z = - z;
+ if ( ( (int16_t)z < 0 ) ^ aSign ) {
+ if ( ( z < 0 ) ^ aSign ) {
+ increment = aSign ? 0 : mask;
+ increment = aSign ? mask : 0;
+ normalizeRoundAndPackFloat128( aSign ^ zSign, bExp - 4, aSig0, aSig1
STATUS_VAR );
+ packFloatx80( aSign, 0x3FFF, LIT64( 0x8000000000000000 ) );
+ pSign = aSign ^ bSign;
+ return 1 - (2 * aSign);
+ return 1 - (2 * aSign); \
+ return 1 - 2 * (aSign ^ ( av < bv )); \
+ return 1 - 2 * (aSign ^ ( lt128( a.high, a.low, b.high, b.low ) ));
+ return addFloat128Sigs( a, b, aSign STATUS_VAR );
+ return addFloat32Sigs( a, b, aSign STATUS_VAR );
+ return addFloat32Sigs( a, b, aSign STATUS_VAR);
+ return addFloat64Sigs( a, b, aSign STATUS_VAR );
+ return addFloatx80Sigs( a, b, aSign STATUS_VAR );
+ return aSign ? a : b; \
+ return (aSign ^ (av < bv)) ? a : b; \
+ return (aSign ^ (av < bv)) ? b : a; \
+ return aSign ? b : a; \
+ return (aSign) ? float32_zero : a;
+ return aSign ? (int32_t) 0x80000000 : 0x7FFFFFFF;
+ return aSign ? (int32_t) 0xffff8000 : 0x7FFF;
+ return ( av == bv ) || ( aSign ^ ( av < bv ) );
+ return ( av != bv ) && ( aSign ^ ( av < bv ) );
+ return make_float32(aSign ? 0x80000000 : 0x3F800000);
+ return make_float32(aSign ? 0xBF800000 : 0);
+ return make_float64(aSign ? LIT64( 0xBFF0000000000000 ) : 0);
+ return normalizeRoundAndPackFloat128( aSign, aExp, aSig0, aSig1
+ return normalizeRoundAndPackFloat32( aSign, aExp, aSig STATUS_VAR );
+ return normalizeRoundAndPackFloat32( aSign ^ zSign, bExp, aSig STATUS_VAR
);
+ return normalizeRoundAndPackFloat64( aSign, aExp, aSig STATUS_VAR );
+ return normalizeRoundAndPackFloat64( aSign ^ zSign, bExp, aSig STATUS_VAR
);
+ return packFloat128( aSign, 0, 0, 0 );
+ return packFloat128( aSign, 0x3FFF, 0, 0 );
+ return packFloat128( aSign, 0x7FFF, 0, 0 );
+ return packFloat128( aSign, aExp + 0x3C00, zSig0, zSig1 );
+ return packFloat128( aSign, aExp + 0x3F80, ( (uint64_t) aSig )<<25, 0 );
+ return packFloat128( aSign, aExp, zSig0, zSig1 );
+ return packFloat16(aSign, 0, 0);
+ return packFloat16(aSign, 0, 0);
+ return packFloat16(aSign, 0x1f, 0);
+ return packFloat16(aSign, 0x1f, 0);
+ return packFloat16(aSign, 0x1f, 0x3ff);
+ return packFloat16(aSign, aExp + 14, aSig >> 13);
+ return packFloat32( aSign, 0, 0 );
+ return packFloat32(aSign, 0, 0);
+ return packFloat32( aSign, 0x7F, 0 );
+ return packFloat32( aSign, 0xFF, 0 );
+ return packFloat32(aSign, 0xff, aSig << 13);
+ return packFloat32( aSign, aExp + 0x70, aSig << 13);
+ return packFloat64( aSign, 0, 0 );
+ return packFloat64( aSign, 0x3FF, 0 );
+ return packFloat64( aSign, 0x7FF, 0 );
+ return packFloat64( aSign, aExp + 0x380, ( (uint64_t) aSig )<<29 );
+ return packFloatx80( aSign, 0, 0 );
+ return packFloatx80( aSign, 0x7FFF, LIT64( 0x8000000000000000 ) );
+ return packFloatx80( aSign, aExp + 0x3F80, ( (uint64_t) aSig )<<40 );
+ return roundAndPackFloat32( aSign, aExp, aSig STATUS_VAR );
+ return roundAndPackFloat32( aSign, aExp, zSig STATUS_VAR );
+ return roundAndPackFloat64( aSign, aExp, aSig0 STATUS_VAR );
+ return roundAndPackFloat64( aSign, aExp, zSig STATUS_VAR );
+ return roundAndPackFloatx80( 80, aSign, aExp, aSig0, aSig1 STATUS_VAR );
+ return roundAndPackInt32( aSign, aSig0 STATUS_VAR );
+ return roundAndPackInt32( aSign, aSig64 STATUS_VAR );
+ return roundAndPackInt32( aSign, aSig STATUS_VAR );
+ return roundAndPackInt64( aSign, aSig0, aSig1 STATUS_VAR );
+ return roundAndPackInt64( aSign, aSig64, aSigExtra STATUS_VAR );
+ return roundAndPackInt64( aSign, aSig, aSigExtra STATUS_VAR );
+ return subFloat128Sigs( a, b, aSign STATUS_VAR );
+ return subFloat32Sigs( a, b, aSign STATUS_VAR );
+ return subFloat64Sigs( a, b, aSign STATUS_VAR );
+ return subFloatx80Sigs( a, b, aSign STATUS_VAR );
+ zSign = aSign;
+ zSign = aSign ^ bSign;
+ char creator[8]; // "conectix"
+ if (buf_size >= 8 && !strncmp((char *)buf, "conectix", 8))
+ if (strncmp(footer->creator, "conectix", 8))
+ memcpy(footer->creator, "conectix", 8);
+void *xtensa_get_extint(CPUState *env, unsigned extint)
+ if (extint < env->config->nextint) {
+ unsigned irq = env->config->extint[extint];
+ __func__, extint);
+ unsigned extint[MAX_NINTERRUPT];
+void *xtensa_get_extint(CPUState *env, unsigned extint);
+ .extint = EXTINTS
+ * LINT0 delivery mode on CPU #0 is set to ExtInt at initialization
+ case 0x23: /* APON */
+ type = SVM_EVTINJ_TYPE_EXEPT;
+ case SVM_EVTINJ_TYPE_EXEPT:
+ qemu_log_mask(CPU_LOG_TB_IN_ASM, "EXEPT");
--
1.7.2.5
- [Qemu-trivial] [PATCH 0/6] New fixes for some misspellings, Stefan Weil, 2011/12/09
- [Qemu-trivial] [PATCH 1/6] Add spelling exceptions for codespell,
Stefan Weil <=
- [Qemu-trivial] [PATCH 3/6] hw: Fix spelling (licenced->licensed), Stefan Weil, 2011/12/09
- [Qemu-trivial] [PATCH 2/6] fmopl: Fix spelling in code and comments, Stefan Weil, 2011/12/09
- [Qemu-trivial] [PATCH 5/6] hw: Fix spelling in comments and code, Stefan Weil, 2011/12/09
- [Qemu-trivial] [PATCH 4/6] hw: Fix spelling in comments, Stefan Weil, 2011/12/09
- [Qemu-trivial] [PATCH 6/6] Fix spelling in comments, documentation and messages, Stefan Weil, 2011/12/09
- Re: [Qemu-trivial] [PATCH 0/6] New fixes for some misspellings, Stefan Hajnoczi, 2011/12/14