#define NAMESPACE_SEPARATOR (dm->style == DMGL_JAVA ? "." : "::")
/* If flag_verbose is zero, some simplifications will be made to the
- output to make it easier to read and supress details that are
+ output to make it easier to read and suppress details that are
generally not of interest to the average C++ programmer.
Otherwise, the demangled representation will attempt to convey as
much information as the mangled form. */
/* Returns non-zero if the character that comes right before the place
where text will be added to the result is a space. In this case,
- the caller should supress adding another space. */
+ the caller should suppress adding another space. */
static int
result_previous_char_is_space (dm)
RETURN_IF_ERROR
(demangle_class_enum_type (dm, &encode_return_type));
/* If all that was just demangled is the two-character
- special substitution token, supress the addition of a
+ special substitution token, suppress the addition of a
new candidate for it. */
if (dm->next == next + 2)
is_substitution_candidate = 0;
end = next + len;
demangled = NULL;
- /* Replace occurances of JArray<TYPE> with TYPE[]. */
+ /* Replace occurrences of JArray<TYPE> with TYPE[]. */
while (next < end)
{
char *open_str = VG_(strstr) (next, "JArray<");
/* This function performs most of what cplus_demangle use to do, but
to be able to demangle a name with a B, K or n code, we need to
have a longer term memory of what types have been seen. The original
- now intializes and cleans up the squangle code info, while internal
+ now initializes and cleans up the squangle code info, while internal
calls go directly to this routine to avoid resetting that info. */
static char *
/* Iterate over occurrences of __, allowing names and types to have a
"__" sequence in them. We must start with the first (not the last)
occurrence, since "__" most often occur between independent mangled
- parts, hence starting at the last occurence inside a signature
+ parts, hence starting at the last occurrence inside a signature
might get us a "successful" demangling of the signature. */
while (scan[2])
<p>
When you're ready to roll, just run your application as you would
normally, but place <code>valgrind --skin=the-selected-skin</code> in
-front of your usual command-line invokation. Note that you should run
+front of your usual command-line invocation. Note that you should run
the real (machine-code) executable here. If your application is
started by, for example, a shell or perl script, you'll need to modify
it to invoke Valgrind on the real executables. Running such scripts
<li>Valgrind's signal simulation is not as robust as it could be.
Basic POSIX-compliant sigaction and sigprocmask functionality is
supplied, but it's conceivable that things could go badly awry
- if you do wierd things with signals. Workaround: don't.
+ if you do weird things with signals. Workaround: don't.
Programs that do non-POSIX signal tricks are in any case
inherently unportable, so should be avoided if
possible.</li><br>
extern Int VG_(clo_dump_error);
/* Number of parents of a backtrace. Default: 8. */
extern Int VG_(clo_backtrace_size);
-/* Engage miscellaneous wierd hacks needed for some progs. */
+/* Engage miscellaneous weird hacks needed for some progs. */
extern Char* VG_(clo_weird_hacks);
/* Should we run __libc_freeres at exit? Sometimes causes crashes.
Default: YES. Note this is subservient to VG_(needs).libc_freeres;
seg_selector &= 0x0000FFFF;
/* Sanity check the segment selector. Ensure that TI=1 (LDT) and
- that RPL=11b (least priviledge). These form the bottom 3 bits
+ that RPL=11b (least privilege). These form the bottom 3 bits
of the selector. */
vg_assert((seg_selector & 7) == 7);
vg_startup.S. We have to determine it early since we can't even
correctly snapshot the startup machine state without it. */
/* Initially True. Safer to err on the side of SSEness and get SIGILL
- than to not notice for some reason that we have SSE and get wierd
+ than to not notice for some reason that we have SSE and get weird
errors later on. */
Bool VG_(have_ssestate) = True;
client really has a handler for this thread! */
vg_assert(vg_dcss.dcss_sigpending[sigNo]);
- /* A recent addition, so as to stop seriously wierd progs dying
+ /* A recent addition, so as to stop seriously weird progs dying
at the following assertion (which this renders redundant,
btw). */
if (vg_scss.scss_per_sig[sigNo].scss_handler == VKI_SIG_IGN
understand this wrong, but I don't think so.
I just had a look at the GDB DWARF2 reader... They
- completly ignore "is_stmt" when recording line info ;-)
+ completely ignore "is_stmt" when recording line info ;-)
That's the reason "objdump -S" works on files from the the
intel fortran compiler.
*/
might return a large offset. Therefore we must not anymore test
for < 0, but test for a real error by making sure the value in %eax
is a real error number. Linus said he will make sure the no syscall
- returns a value in -1 .. -4095 as a valid result so we can savely
+ returns a value in -1 .. -4095 as a valid result so we can safely
test with -4095.
END QUOTE
if (dis) VG_(printf)("leave");
break;
- /* ---------------- Misc wierd-ass insns --------------- */
+ /* ---------------- Misc weird-ass insns --------------- */
case 0x27: /* DAA */
case 0x2F: /* DAS */
* segments are arranged to form an interference graph which indicates
* whether two thread lifetime segments can possibly be concurrent.
* If not, then memory with is exclusively accessed by one TLS can be
- * passed on to another TLS without an error occuring, and without
+ * passed on to another TLS without an error occurring, and without
* moving it from Excl state.
*
* At present this only considers thread creation and join as
enum {
NOP, /* Null op */
- LOCK, /* Indicate the existance of a LOCK prefix (functionally NOP) */
+ LOCK, /* Indicate the existence of a LOCK prefix (functionally NOP) */
/* Moving values around */
GET, PUT, /* simulated register <--> TempReg */
Once you understand the meaning of the instrumentation uinstrs,
discussed in detail above, the instrumentation scheme is fairly
-straighforward. Each uinstr is instrumented in isolation, and the
+straightforward. Each uinstr is instrumented in isolation, and the
instrumentation uinstrs are placed before the original uinstr.
Our running example continues below. I have placed a blank line
after every original ucode, to make it easier to see which
original program to (seg)fault. So the use of values as memory
addresses causes a check, as do conditional jumps (these cause a check
on the definedness of the condition codes). And arguments
-<code>PUSH</code>ed for helper calls are checked, hence the wierd
+<code>PUSH</code>ed for helper calls are checked, hence the weird
restrictions on help call preambles described above.
<p>
else
tpool->queue_head = my_workp->next;
- printf("worker %d: dequeing item %d\n", pthread_self(), my_workp->next);
+ printf("worker %d: dequeuing item %d\n", pthread_self(), my_workp->next);
/* Handle waiting add_work threads */
if ((!tpool->do_not_block_when_full) &&
projects / thirdparty / valgrind.git / commitdiff
