static void print_character (STREAM stream, D instance, BOOL escape_p, int print_depth) {
ignore(print_depth);
if (escape_p) {
format(stream, "'%c'", R(instance))
} else {
/* Sets 'latch'.
*
* Calls are not additive: a single latch_poll() clears out any number of
* latch_set(). */
void
latch_set(struct latch *latch)
{
ignore(write(latch->fds[1], "", 1));
}
D primitive_make_thread(D t, D n, D p, D f, DBOOL s) {
ignore(t); ignore(n); ignore(p); ignore(f); ignore(s);
/* threads_get_stuffed(); */
return(THREAD_SUCCESS); /* Keeps some compilers happy -- Won't actually get here */
}
void print_symbol_name (STREAM stream, D instance, BOOL escape_p, int print_depth) {
ignore(escape_p);
print_object(stream, dylan_symbol_name(instance), TRUE, print_depth);
}
void print_class_debug_name (STREAM stream, D instance, BOOL escape_p, int print_depth) {
D name = dylan_class_debug_name(instance);
ignore(escape_p);
print_string_data(stream, name, TRUE, print_depth);
}
void SpellChecker::add()
{
m_dictionary.addWord(m_word);
ignore();
}
void print_string_data (STREAM stream, D instance, BOOL escape_p, int print_depth) {
ignore(escape_p); ignore(print_depth);
format(stream, "%s", string_data(instance));
}
struct ovsdb_error *
ovsdb_log_write(struct ovsdb_log *file, struct json *json)
{
uint8_t sha1[SHA1_DIGEST_SIZE];
struct ovsdb_error *error;
char *json_string;
char header[128];
size_t length;
json_string = NULL;
if (file->mode == OVSDB_LOG_READ || file->write_error) {
file->mode = OVSDB_LOG_WRITE;
file->write_error = false;
if (fseeko(file->stream, file->offset, SEEK_SET)) {
error = ovsdb_io_error(errno, "%s: cannot seek to offset %lld",
file->name, (long long int) file->offset);
goto error;
}
if (ftruncate(fileno(file->stream), file->offset)) {
error = ovsdb_io_error(errno, "%s: cannot truncate to length %lld",
file->name, (long long int) file->offset);
goto error;
}
}
if (json->type != JSON_OBJECT && json->type != JSON_ARRAY) {
error = OVSDB_BUG("bad JSON type");
goto error;
}
/* Compose content. Add a new-line (replacing the null terminator) to make
* the file easier to read, even though it has no semantic value. */
json_string = json_to_string(json, 0);
length = strlen(json_string) + 1;
json_string[length - 1] = '\n';
/* Compose header. */
sha1_bytes(json_string, length, sha1);
snprintf(header, sizeof header, "%s%"PRIuSIZE" "SHA1_FMT"\n",
magic, length, SHA1_ARGS(sha1));
/* Write. */
if (fwrite(header, strlen(header), 1, file->stream) != 1
|| fwrite(json_string, length, 1, file->stream) != 1
|| fflush(file->stream))
{
error = ovsdb_io_error(errno, "%s: write failed", file->name);
/* Remove any partially written data, ignoring errors since there is
* nothing further we can do. */
ignore(ftruncate(fileno(file->stream), file->offset));
goto error;
}
file->offset += strlen(header) + length;
free(json_string);
return NULL;
error:
file->write_error = true;
free(json_string);
return error;
}
static bool read_connection(Streader* sr, int32_t index, void* userdata)
{
rassert(sr != NULL);
rassert(userdata != NULL);
ignore(index);
read_conn_data* rcdata = userdata;
char src_name[KQT_DEVICE_NODE_NAME_MAX] = "";
char dest_name[KQT_DEVICE_NODE_NAME_MAX] = "";
if (!Streader_readf(
sr,
"[%s,%s]",
READF_STR(KQT_DEVICE_NODE_NAME_MAX, src_name),
READF_STR(KQT_DEVICE_NODE_NAME_MAX, dest_name)))
return false;
int src_port = validate_connection_path(
sr, src_name, rcdata->level, DEVICE_PORT_TYPE_SEND);
int dest_port = validate_connection_path(
sr, dest_name, rcdata->level, DEVICE_PORT_TYPE_RECV);
if (Streader_is_error_set(sr))
return false;
if (rcdata->level == CONNECTION_LEVEL_AU)
{
if (string_eq(src_name, ""))
strcpy(src_name, "Iin");
}
if (AAtree_get_exact(rcdata->graph->nodes, src_name) == NULL)
{
const Device* actual_master = rcdata->master;
if ((rcdata->level == CONNECTION_LEVEL_AU) &&
string_eq(src_name, "Iin"))
actual_master = Audio_unit_get_input_interface((Audio_unit*)rcdata->master);
Device_node* new_src = new_Device_node(
src_name, rcdata->au_table, actual_master);
mem_error_if(new_src == NULL, rcdata->graph, NULL, sr);
mem_error_if(
!AAtree_ins(rcdata->graph->nodes, new_src),
rcdata->graph,
new_src,
sr);
}
Device_node* src_node = AAtree_get_exact(rcdata->graph->nodes, src_name);
if (AAtree_get_exact(rcdata->graph->nodes, dest_name) == NULL)
{
Device_node* new_dest = new_Device_node(
dest_name, rcdata->au_table, rcdata->master);
mem_error_if(new_dest == NULL, rcdata->graph, NULL, sr);
mem_error_if(
!AAtree_ins(rcdata->graph->nodes, new_dest),
rcdata->graph,
new_dest,
sr);
}
Device_node* dest_node = AAtree_get_exact(rcdata->graph->nodes, dest_name);
rassert(src_node != NULL);
rassert(dest_node != NULL);
mem_error_if(
!Device_node_connect(dest_node, dest_port, src_node, src_port),
rcdata->graph,
NULL,
sr);
return true;
}
/* Handles fatal signal number 'sig_nr'.
*
* Ordinarily this is the actual signal handler. When other code needs to
* handle one of our signals, however, it can register for that signal and, if
* and when necessary, call this function to do fatal signal processing for it
* and terminate the process. Currently only timeval.c does this, for SIGALRM.
* (It is not important whether the other code sets up its signal handler
* before or after this file, because this file will only set up a signal
* handler in the case where the signal has its default handling.) */
void
fatal_signal_handler(int sig_nr)
{
ignore(write(signal_fds[1], "", 1));
stored_sig_nr = sig_nr;
}
static bool read_entry(Streader* sr, int32_t index, void* userdata)
{
rassert(sr != NULL);
rassert(userdata != NULL);
ignore(index);
Input_map* im = userdata;
int64_t in = 0;
int64_t out = 0;
if (!Streader_readf(sr, "[%i, %i]", &in, &out))
return false;
if (in < 0 || in >= im->num_inputs)
{
Streader_set_error(
sr,
"Input ID %" PRId64 " out of range [0, %" PRId32 ")",
in, im->num_inputs);
return false;
}
if (out < 0 || out >= im->num_outputs)
{
Streader_set_error(
sr,
"Output ID %" PRId64 " out of range [0, %" PRId32 ")",
out, im->num_outputs);
return false;
}
const Entry* key = ENTRY_KEY((int32_t)in);
if (AAtree_contains(im->map, key))
{
Streader_set_error(sr, "Duplicate entry for input %" PRId64, in);
return false;
}
Entry* entry = memory_alloc_item(Entry);
if (entry == NULL)
{
Error_set(
&sr->error,
ERROR_MEMORY,
"Could not allocate memory for input map");
return false;
}
entry->input = (int32_t)in;
entry->output = (int32_t)out;
if (!AAtree_ins(im->map, entry))
{
memory_free(entry);
Error_set(
&sr->error,
ERROR_MEMORY,
"Could not allocate memory for input map");
return false;
}
return true;
}
int timing_get_wall(uint64_t *const result)
{
ignore(result);
return -1;
}
static int check_all(NOARGS)
{
struct fs_info *fs = NULL;
int status = EXIT_OK;
int not_done_yet = 1;
int passno = 1;
int pass_done;
if (verbose)
fputs(_("Checking all file systems.\n"), stdout);
for (fs = filesys_info; fs; fs = fs->next) {
if (ignore(fs))
fs->flags |= FLAG_DONE;
}
if (!parallel_root) {
for (fs = filesys_info; fs; fs = fs->next) {
if (!strcmp(fs->mountpt, "/"))
break;
}
if (fs) {
if (!skip_root && !ignore(fs) &&
!(ignore_mounted && is_mounted(fs->device))) {
fsck_device(fs, 1);
status |= wait_many(FLAG_WAIT_ALL);
if (status > EXIT_NONDESTRUCT)
return status;
}
fs->flags |= FLAG_DONE;
}
}
if (skip_root)
for (fs = filesys_info; fs; fs = fs->next)
if (!strcmp(fs->mountpt, "/"))
fs->flags |= FLAG_DONE;
while (not_done_yet) {
not_done_yet = 0;
pass_done = 1;
for (fs = filesys_info; fs; fs = fs->next) {
if (cancel_requested)
break;
if (fs->flags & FLAG_DONE)
continue;
if (fs->passno > passno) {
not_done_yet++;
continue;
}
if (ignore_mounted && is_mounted(fs->device)) {
fs->flags |= FLAG_DONE;
continue;
}
if (device_already_active(fs->device)) {
pass_done = 0;
continue;
}
fsck_device(fs, serialize);
fs->flags |= FLAG_DONE;
if (serialize ||
(max_running && (num_running >= max_running))) {
pass_done = 0;
break;
}
}
if (cancel_requested)
break;
if (verbose > 1)
printf(_("--waiting-- (pass %d)\n"), passno);
status |= wait_many(pass_done ? FLAG_WAIT_ALL :
FLAG_WAIT_ATLEAST_ONE);
if (pass_done) {
if (verbose > 1)
printf("----------------------------------\n");
passno++;
} else
not_done_yet++;
}
if (cancel_requested && !kill_sent) {
kill_all(SIGTERM);
kill_sent++;
}
status |= wait_many(FLAG_WAIT_ATLEAST_ONE);
return status;
}
/*
* Find over structure, repeated count times.
* Don't go past line limit. F is the operation to
* be performed eventually. If pastatom then the user said {}
* rather than (), implying past atoms in a list (or a paragraph
* rather than a sentence.
*/
int
llfind(bool pastatom, int cnt, void (*f)(int), line *limit)
{
#ifdef LISPCODE
register int c;
#endif
register int rc = 0;
char *save = smalloc(LBSIZE);
/*
* Initialize, saving the current line buffer state
* and computing the limit; a 0 argument means
* directional end of file.
*/
wasend = 0;
lf = f;
lcpy(save, linebuf, LBSIZE);
if (limit == 0)
limit = dir < 0 ? one : dol;
llimit = limit;
wdot = dot;
wcursor = cursor;
if (pastatom >= 2) {
while (cnt > 0 && word(f, cnt))
cnt--;
if (pastatom == 3)
eend(f);
if (dot == wdot) {
wdot = 0;
if (cursor == wcursor)
rc = -1;
}
}
#ifdef LISPCODE
else if (!value(LISP)) {
#else
else {
#endif
char *icurs;
line *idot;
if (linebuf[0] == 0) {
do
if (!lnext())
goto ret;
while (linebuf[0] == 0);
if (dir > 0) {
wdot--;
linebuf[0] = 0;
wcursor = linebuf;
/*
* If looking for sentence, next line
* starts one.
*/
if (!pastatom) {
icurs = wcursor;
idot = wdot;
goto begin;
}
}
}
icurs = wcursor;
idot = wdot;
/*
* Advance so as to not find same thing again.
*/
if (dir > 0) {
if (!lnext()) {
rc = -1;
goto ret;
}
} else
ignore(lskipa1(""));
/*
* Count times find end of sentence/paragraph.
*/
begin:
for (;;) {
while (!endsent(pastatom))
if (!lnext())
goto ret;
if (!pastatom || (wcursor == linebuf && endPS()))
if (--cnt <= 0)
break;
if (linebuf[0] == 0) {
do
if (!lnext())
goto ret;
while (linebuf[0] == 0);
} else
if (!lnext())
goto ret;
}
/*
* If going backwards, and didn't hit the end of the buffer,
* then reverse direction.
*/
if (dir < 0 && (wdot != llimit || wcursor != linebuf)) {
dir = 1;
llimit = dot;
/*
* Empty line needs special treatement.
* If moved to it from other than begining of next line,
* then a sentence starts on next line.
*/
if (linebuf[0] == 0 && !pastatom &&
(wdot != dot - 1 || cursor != linebuf)) {
lnext();
goto ret;
}
}
/*
* If we are not at a section/paragraph division,
* advance to next.
*/
if ((wcursor == icurs && wdot == idot) || wcursor != linebuf || !endPS())
ignore(lskipa1(""));
}
#ifdef LISPCODE
else {
c = *wcursor;
/*
* Startup by skipping if at a ( going left or a ) going
* right to keep from getting stuck immediately.
*/
if ((dir < 0 && c == '(') || (dir > 0 && c == ')')) {
if (!lnext()) {
rc = -1;
goto ret;
}
}
/*
* Now chew up repitition count. Each time around
* if at the beginning of an s-exp (going forwards)
* or the end of an s-exp (going backwards)
* skip the s-exp. If not at beg/end resp, then stop
* if we hit a higher level paren, else skip an atom,
* counting it unless pastatom.
*/
while (cnt > 0) {
c = *wcursor;
if ((dir < 0 && c == ')') || (dir > 0 && c == '(')) {
if (!lskipbal("()"))
goto ret;
/*
* Unless this is the last time going
* backwards, skip past the matching paren
* so we don't think it is a higher level paren.
*/
if (dir < 0 && cnt == 1)
goto ret;
if (!lnext() || !ltosolid())
goto ret;
--cnt;
} else if ((dir < 0 && c == '(') || (dir > 0 && c == ')'))
/* Found a higher level paren */
goto ret;
else {
if (!lskipatom())
goto ret;
if (!pastatom)
--cnt;
}
}
}
#endif
ret:
strcLIN(save);
free(save);
return (rc);
}
void
oop(void)
{
register char *ic;
#if 0
char atube[TUBESIZE + LBSIZE];
#endif
ttymode f; /* mjm: was register */
ovbeg();
if (peekchar() == '/') {
ignore(compile(ex_getchar(), 1));
savere(scanre);
if (execute(0, dot) == 0)
error("Fail|Pattern not found on addressed line");
ic = loc1;
if (ic > linebuf && *ic == 0)
ic--;
} else {
getDOT();
ic = vskipwh(linebuf);
}
ex_newline();
/*
* If overstrike then have to HARDOPEN
* else if can move cursor up off current line can use CRTOPEN (~~vi1)
* otherwise (ugh) have to use ONEOPEN (like adm3)
*/
if (OS && !EO)
bastate = HARDOPEN;
else if (CA || UP)
bastate = CRTOPEN;
else
bastate = ONEOPEN;
setwind();
/*
* To avoid bombing on glass-crt's when the line is too long
* pretend that such terminals are 160 columns wide.
* If a line is too wide for display, we will dynamically
* switch to hardcopy open mode.
*/
if (state != CRTOPEN)
WCOLS = TUBECOLS;
if (!inglobal)
savevis();
vok(atube);
if (state != CRTOPEN)
COLUMNS = WCOLS;
Outchar = vputchar;
f = ostart();
if (state == CRTOPEN) {
if (outcol == UKCOL)
outcol = 0;
vmoveitup(1, 1);
} else
outline = destline = WBOT;
vshow(dot, NOLINE);
vnline(ic);
vmain();
if (state != CRTOPEN)
vclean();
Command = "open";
ovend(f);
}
/**
* Test various generic API methods of SelectFormat for Basic API usage.
* This is to make sure the API test coverage is 100% .
*/
void SelectFormatTest::selectFormatAPITest(/*char *par*/)
{
const UnicodeString SIMPLE_PATTERN(SIMPLE_PATTERN_STRING); /* Don't static init this! */
int numOfConstructors =3;
UErrorCode status[3];
SelectFormat* selFmt[3] = { NULL, NULL, NULL };
// ========= Test constructors
logln("SelectFormat API test: Testing SelectFormat constructors ...");
for (int32_t i=0; i< numOfConstructors; ++i) {
status[i] = U_ZERO_ERROR;
}
selFmt[0]= new SelectFormat(SIMPLE_PATTERN, status[0]);
if ( U_FAILURE(status[0]) ) {
errln("ERROR: SelectFormat API test constructor with pattern and status failed! with %s\n", u_errorName(status[0]));
return;
}
// =========== Test copy constructor
logln("SelectFormat API test: Testing copy constructor and == operator ...");
SelectFormat fmt = *selFmt[0];
SelectFormat* dupPFmt = new SelectFormat(fmt);
if ((*selFmt[0]) != (*dupPFmt)) {
errln("ERROR: SelectFormat API test Failed in copy constructor or == operator!");
}
delete dupPFmt;
// ======= Test clone && == operator.
logln("SelectFormat API test: Testing clone and == operator ...");
if ( U_SUCCESS(status[0]) ) {
selFmt[1] = (SelectFormat*)selFmt[0]->clone();
if (selFmt[1]!=NULL) {
if ( *selFmt[1] != *selFmt[0] ) {
errln("ERROR: SelectFormat API test clone test failed!");
}
} else {
errln("ERROR: SelectFormat API test clone test failed with NULL!");
return;
}
} else {
errln("ERROR: could not create [0]: %s\n", u_errorName(status[0]));
return;
}
// ======= Test assignment operator && == operator.
logln("SelectFormat API test: Testing assignment operator and == operator ...");
selFmt[2]= new SelectFormat(SIMPLE_PATTERN, status[2]);
if ( U_SUCCESS(status[2]) ) {
*selFmt[1] = *selFmt[2];
if (selFmt[1]!=NULL) {
if ( (*selFmt[1] != *selFmt[2]) ) {
errln("ERROR: SelectFormat API test assignment operator test failed!");
}
}
delete selFmt[1];
}
else {
errln("ERROR: SelectFormat constructor failed in assignment operator!");
}
delete selFmt[0];
delete selFmt[2];
// ======= Test getStaticClassID() and getStaticClassID()
logln("SelectFormat API test: Testing getStaticClassID() and getStaticClassID() ...");
UErrorCode status1 = U_ZERO_ERROR;
SelectFormat* selFmt1 = new SelectFormat( SIMPLE_PATTERN , status1);
if( U_FAILURE(status1)) {
errln("ERROR: SelectFormat constructor failed in staticClassID test! Exitting");
return;
}
logln("Testing getStaticClassID()");
if(selFmt1->getDynamicClassID() !=SelectFormat::getStaticClassID()) {
errln("ERROR: SelectFormat API test getDynamicClassID() didn't return the expected value");
}
// ======= Test applyPattern() and toPattern()
logln("SelectFormat API test: Testing applyPattern() and toPattern() ...");
UnicodeString pattern = UnicodeString("masculine{masculineVerbValue} other{otherVerbValue}");
status1 = U_ZERO_ERROR;
selFmt1->applyPattern( pattern, status1);
if (U_FAILURE(status1)) {
errln("ERROR: SelectFormat API test failed in applyPattern() with pattern: "+ pattern);
}else{
UnicodeString checkPattern;
selFmt1->toPattern( checkPattern);
if( checkPattern != pattern ){
errln("ERROR: SelectFormat API test failed in toPattern() with unexpected result with pattern: "+ pattern);
}
}
// ======= Test different format() methods
logln("SelectFormat API test: Testing format() with keyword method ...");
status1 = U_ZERO_ERROR;
UnicodeString result;
FieldPosition ignore(FieldPosition::DONT_CARE);
UnicodeString keyWord = UnicodeString("masculine");
selFmt1->format( keyWord, result , ignore , status1);
if (U_FAILURE(status1)) {
errln("ERROR: SelectFormat API test failed in format() with keyWord: "+ keyWord);
}else{
UnicodeString expected=UnicodeString("masculineVerbValue");
if( result != expected ){
errln("ERROR: SelectFormat API test failed in format() with unexpected result with keyWord: "+ keyWord);
}
}
logln("SelectFormat API test: Testing format() with Formattable obj method ...");
status1 = U_ZERO_ERROR;
result.remove();
UnicodeString result1;
Formattable testArgs = Formattable("other");
selFmt1->format( testArgs, result1 , ignore , status1);
if (U_FAILURE(status1)) {
errln("ERROR: SelectFormat API test failed in format() with Formattable");
}else{
UnicodeString expected=UnicodeString("otherVerbValue");
if( result1 != expected ){
errln("ERROR: SelectFormat API test failed in format() with unexpected result with Formattable");
}
}
delete selFmt1;
}
/*
* Main loop for command mode command decoding.
* A few commands are executed here, but main function
* is to strip command addresses, do a little address oriented
* processing and call command routines to do the real work.
*/
void
commands(bool noprompt, bool exitoneof)
{
register line *addr;
register int c;
register int lchng;
int given;
int seensemi;
int cnt;
bool hadpr;
resetflav();
nochng();
for (;;) {
/*
* If dot at last command
* ended up at zero, advance to one if there is a such.
*/
if (dot <= zero) {
dot = zero;
if (dol > zero)
dot = one;
}
shudclob = 0;
/*
* If autoprint or trailing print flags,
* print the line at the specified offset
* before the next command.
*/
if (pflag ||
(lchng != chng && value(AUTOPRINT) && !inglobal && !inopen && endline)) {
pflag = 0;
nochng();
if (dol != zero) {
addr1 = addr2 = dot + poffset;
if (addr1 < one || addr1 > dol)
error("Offset out-of-bounds|Offset after command too large");
setdot1();
goto print;
}
}
nochng();
/*
* Print prompt if appropriate.
* If not in global flush output first to prevent
* going into pfast mode unreasonably.
*/
if (inglobal == 0) {
flush();
if (!hush && value(PROMPT) && !globp && !noprompt && endline) {
ex_putchar(':');
hadpr = 1;
}
TSYNC();
}
/*
* Gobble up the address.
* Degenerate addresses yield ".".
*/
addr2 = 0;
given = seensemi = 0;
do {
addr1 = addr2;
addr = address(0);
c = getcd();
if (addr == 0) {
if (c == ',')
addr = dot;
else if (addr1 != 0) {
addr2 = dot;
break;
} else
break;
}
addr2 = addr;
given++;
if (c == ';') {
c = ',';
dot = addr;
seensemi = 1;
}
} while (c == ',');
if (c == '%') {
/* %: same as 1,$ */
addr1 = one;
addr2 = dol;
given = 2;
c = ex_getchar();
}
if (addr1 == 0)
addr1 = addr2;
if (c == ':')
c = ex_getchar();
/*
* Set command name for special character commands.
*/
tailspec(c);
/*
* If called via : escape from open or visual, limit
* the set of available commands here to save work below.
*/
if (inopen) {
if (c=='\n' || c=='\r' || c==CTRL('d') || c==EOF) {
if (addr2)
dot = addr2;
if (c == EOF)
return;
continue;
}
if (any(c, "o"))
notinvis:
tailprim(Command, 1, 1);
}
switch (c) {
case 'a':
switch(peekchar()) {
case 'b':
/* abbreviate */
tail("abbreviate");
setnoaddr();
mapcmd(0, 1);
anyabbrs = 1;
continue;
case 'r':
/* args */
tail("args");
setnoaddr();
eol();
pargs();
continue;
}
/* append */
if (inopen)
goto notinvis;
tail("append");
setdot();
aiflag = exclam();
ex_newline();
vmacchng(0);
deletenone();
setin(addr2);
inappend = 1;
ignore(append(gettty, addr2));
inappend = 0;
nochng();
continue;
case 'c':
switch (peekchar()) {
/* copy */
case 'o':
tail("copy");
vmacchng(0);
move();
continue;
#ifdef CHDIR
/* cd */
case 'd':
tail("cd");
goto changdir;
/* chdir */
case 'h':
ignchar();
if (peekchar() == 'd') {
register char *p;
tail2of("chdir");
changdir:
if (savedfile[0] == '/' || !value(WARN))
ignore(exclam());
else
ignore(quickly());
if (skipend()) {
p = getenv("HOME");
if (p == NULL)
error("Home directory unknown");
} else
getone(), p = file;
eol();
if (chdir(p) < 0)
filioerr(p);
if (savedfile[0] != '/')
edited = 0;
continue;
}
if (inopen)
tailprim("change", 2, 1);
tail2of("change");
break;
#endif
default:
if (inopen)
goto notinvis;
tail("change");
break;
}
/* change */
aiflag = exclam();
setCNL();
vmacchng(0);
setin(addr1);
delete(0);
inappend = 1;
ignore(append(gettty, addr1 - 1));
inappend = 0;
nochng();
continue;
/* delete */
case 'd':
/*
* Caution: dp and dl have special meaning already.
*/
tail("delete");
c = cmdreg();
setCNL();
vmacchng(0);
if (c)
YANKreg(c);
delete(0);
appendnone();
continue;
/* edit */
/* ex */
case 'e':
tail(peekchar() == 'x' ? "ex" : "edit");
editcmd:
if (!exclam() && chng)
c = 'E';
filename(c);
if (c == 'E') {
ungetchar(lastchar());
ignore(quickly());
}
setnoaddr();
doecmd:
init();
addr2 = zero;
laste++;
ex_sync();
rop(c);
nochng();
continue;
/* file */
case 'f':
tail("file");
setnoaddr();
filename(c);
noonl();
/*
synctmp();
*/
continue;
/* global */
case 'g':
tail("global");
global(!exclam());
nochng();
continue;
/* insert */
case 'i':
if (inopen)
goto notinvis;
tail("insert");
setdot();
nonzero();
aiflag = exclam();
ex_newline();
vmacchng(0);
deletenone();
setin(addr2);
inappend = 1;
ignore(append(gettty, addr2 - 1));
inappend = 0;
if (dot == zero && dol > zero)
dot = one;
nochng();
continue;
/* join */
case 'j':
tail("join");
c = exclam();
setcount();
nonzero();
ex_newline();
vmacchng(0);
if (given < 2 && addr2 != dol)
addr2++;
join(c);
continue;
/* k */
case 'k':
casek:
pastwh();
c = ex_getchar();
if (endcmd(c))
serror("Mark what?|%s requires following letter", Command);
ex_newline();
if (!islower(c))
error("Bad mark|Mark must specify a letter");
setdot();
nonzero();
names[c - 'a'] = *addr2 &~ 01;
anymarks = 1;
continue;
/* list */
case 'l':
tail("list");
setCNL();
ignorf(setlist(1));
pflag = 0;
goto print;
case 'm':
if (peekchar() == 'a') {
ignchar();
if (peekchar() == 'p') {
/* map */
tail2of("map");
setnoaddr();
mapcmd(0, 0);
continue;
}
/* mark */
tail2of("mark");
goto casek;
}
/* move */
tail("move");
vmacchng(0);
move();
continue;
case 'n':
if (peekchar() == 'u') {
tail("number");
goto numberit;
}
/* next */
tail("next");
setnoaddr();
ckaw();
ignore(quickly());
if (getargs())
makargs();
next();
c = 'e';
filename(c);
goto doecmd;
/* open */
case 'o':
tail("open");
oop();
pflag = 0;
nochng();
continue;
case 'p':
case 'P':
switch (peekchar()) {
/* put */
case 'u':
tail("put");
setdot();
c = cmdreg();
eol();
vmacchng(0);
if (c)
putreg(c);
else
put();
continue;
case 'r':
ignchar();
if (peekchar() == 'e') {
/* preserve */
tail2of("preserve");
eol();
if (preserve() == 0)
error("Preserve failed!");
else
error("File preserved.");
}
tail2of("print");
break;
default:
tail("print");
break;
}
/* print */
setCNL();
pflag = 0;
print:
nonzero();
if (CL && span() > EX_LINES) {
flush1();
vclear();
}
plines(addr1, addr2, 1);
continue;
/* quit */
case 'q':
tail("quit");
setnoaddr();
c = quickly();
eol();
if (!c)
quit:
nomore();
if (inopen) {
vgoto(WECHO, 0);
if (!ateopr())
vnfl();
else {
tostop();
}
flush();
setty(normf);
}
cleanup(1);
ex_exit(0);
case 'r':
if (peekchar() == 'e') {
ignchar();
switch (peekchar()) {
/* rewind */
case 'w':
tail2of("rewind");
setnoaddr();
if (!exclam()) {
ckaw();
if (chng && dol > zero)
error("No write@since last chage (:rewind! overrides)");
}
eol();
erewind();
next();
c = 'e';
ungetchar(lastchar());
filename(c);
goto doecmd;
/* recover */
case 'c':
tail2of("recover");
setnoaddr();
c = 'e';
if (!exclam() && chng)
c = 'E';
filename(c);
if (c == 'E') {
ungetchar(lastchar());
ignore(quickly());
}
init();
addr2 = zero;
laste++;
ex_sync();
recover();
rop2();
revocer();
if (status == 0)
rop3(c);
if (dol != zero)
change();
nochng();
continue;
}
tail2of("read");
} else
tail("read");
/* read */
if (savedfile[0] == 0 && dol == zero)
c = 'e';
pastwh();
vmacchng(0);
if (peekchar() == '!') {
setdot();
ignchar();
unix0(0);
filter(0);
continue;
}
filename(c);
rop(c);
nochng();
if (inopen && endline && addr1 > zero && addr1 < dol)
dot = addr1 + 1;
continue;
case 's':
switch (peekchar()) {
/*
* Caution: 2nd char cannot be c, g, or r
* because these have meaning to substitute.
*/
/* set */
case 'e':
tail("set");
setnoaddr();
set();
continue;
/* shell */
case 'h':
tail("shell");
setNAEOL();
vnfl();
putpad(TE);
flush();
unixwt(1, unixex("-i", (char *) 0, 0, 0));
vcontin(0);
continue;
/* source */
case 'o':
#ifdef notdef
if (inopen)
goto notinvis;
#endif
tail("source");
setnoaddr();
getone();
eol();
source(file, 0);
continue;
#ifdef SIGTSTP
/* stop, suspend */
case 't':
tail("stop");
goto suspend;
case 'u':
tail("suspend");
suspend:
if (!dosusp)
error("Old tty driver|Not using new tty driver/shell");
c = exclam();
eol();
if (!c)
ckaw();
onsusp(0);
continue;
#endif
}
/* fall into ... */
/* & */
/* ~ */
/* substitute */
case '&':
case '~':
Command = "substitute";
if (c == 's')
tail(Command);
vmacchng(0);
if (!substitute(c))
pflag = 0;
continue;
/* t */
case 't':
if (peekchar() == 'a') {
tail("tag");
tagfind(exclam());
if (!inopen)
lchng = chng - 1;
else
nochng();
continue;
}
tail("t");
vmacchng(0);
move();
continue;
case 'u':
if (peekchar() == 'n') {
ignchar();
switch(peekchar()) {
/* unmap */
case 'm':
tail2of("unmap");
setnoaddr();
mapcmd(1, 0);
continue;
/* unabbreviate */
case 'a':
tail2of("unabbreviate");
setnoaddr();
mapcmd(1, 1);
anyabbrs = 1;
continue;
}
/* undo */
tail2of("undo");
} else
tail("undo");
setnoaddr();
markDOT();
c = exclam();
ex_newline();
undo(c);
continue;
case 'v':
switch (peekchar()) {
case 'e':
/* version */
tail("version");
setNAEOL();
ex_printf("@(#) Version 3.6, 11/3/80"
" (4.0BSD). git "
"160803 14:24"
+5);
noonl();
continue;
/* visual */
case 'i':
tail("visual");
if (inopen) {
c = 'e';
goto editcmd;
}
vop();
pflag = 0;
nochng();
continue;
}
/* v */
tail("v");
global(0);
nochng();
continue;
/* write */
case 'w':
c = peekchar();
tail(c == 'q' ? "wq" : "write");
wq:
if (skipwh() && peekchar() == '!') {
pofix();
ignchar();
setall();
unix0(0);
filter(1);
} else {
setall();
wop(1);
nochng();
}
if (c == 'q')
goto quit;
continue;
/* xit */
case 'x':
tail("xit");
if (!chng)
goto quit;
c = 'q';
goto wq;
/* yank */
case 'y':
tail("yank");
c = cmdreg();
setcount();
eol();
vmacchng(0);
if (c)
YANKreg(c);
else
yank();
continue;
/* z */
case 'z':
zop(0);
pflag = 0;
continue;
/* * */
/* @ */
case '*':
case '@':
c = ex_getchar();
if (c=='\n' || c=='\r')
ungetchar(c);
if (any(c, "@*\n\r"))
c = lastmac;
if (isupper(c))
c = tolower(c);
if (!islower(c))
error("Bad register");
ex_newline();
setdot();
cmdmac(c);
continue;
/* | */
case '|':
endline = 0;
goto caseline;
/* \n */
case '\n':
endline = 1;
caseline:
notempty();
if (addr2 == 0) {
if (UP != NOSTR && c == '\n' && !inglobal)
c = CTRL('k');
if (inglobal)
addr1 = addr2 = dot;
else {
if (dot == dol)
error("At EOF|At end-of-file");
addr1 = addr2 = dot + 1;
}
}
setdot();
nonzero();
if (seensemi)
addr1 = addr2;
ex_getline(*addr1);
if (c == CTRL('k')) {
flush1();
destline--;
if (hadpr)
shudclob = 1;
}
plines(addr1, addr2, 1);
continue;
/* " */
case '"':
comment();
continue;
/* # */
case '#':
numberit:
setCNL();
ignorf(setnumb(1));
pflag = 0;
goto print;
/* = */
case '=':
ex_newline();
setall();
if (inglobal == 2)
pofix();
ex_printf("%d", lineno(addr2));
noonl();
continue;
/* ! */
case '!':
if (addr2 != 0) {
vmacchng(0);
unix0(0);
setdot();
filter(2);
} else {
unix0(1);
pofix();
putpad(TE);
flush();
unixwt(1, unixex("-c", uxb, 0, 0));
vclrech(1); /* vcontin(0); */
nochng();
}
continue;
/* < */
/* > */
case '<':
case '>':
for (cnt = 1; peekchar() == c; cnt++)
ignchar();
setCNL();
vmacchng(0);
shift(c, cnt);
continue;
/* ^D */
/* EOF */
case CTRL('d'):
case EOF:
if (exitoneof) {
if (addr2 != 0)
dot = addr2;
return;
}
if (!isatty(0)) {
if (intty)
/*
* Chtty sys call at UCB may cause a
* input which was a tty to suddenly be
* turned into /dev/null.
*/
onhup(0);
return;
}
if (addr2 != 0) {
setlastchar('\n');
putnl();
}
if (dol == zero) {
if (addr2 == 0)
putnl();
notempty();
}
ungetchar(EOF);
zop(hadpr);
continue;
default:
if (!isalpha(c))
break;
ungetchar(c);
tailprim("", 0, 0);
}
ierror("What?|Unknown command character '%c'", c);
}
}
/**
* Unit tests of SelectFormat class.
*/
void SelectFormatTest::selectFormatUnitTest(/*char *par*/)
{
const UnicodeString SIMPLE_PATTERN(SIMPLE_PATTERN_STRING); /* Don't static init this! */
UnicodeString patternTestData[SELECT_PATTERN_DATA] = {
UNICODE_STRING_SIMPLE("fem {femValue} other{even}"),
UNICODE_STRING_SIMPLE("other{odd or even}"),
UNICODE_STRING_SIMPLE("odd{The number {0, number, integer} is odd.}other{The number {0, number, integer} is even.}"),
UNICODE_STRING_SIMPLE("odd{The number {1} is odd}other{The number {1} is even}"),
};
UnicodeString formatArgs[NUM_OF_FORMAT_ARGS] = {
UNICODE_STRING_SIMPLE("fem"),
UNICODE_STRING_SIMPLE("other"),
UNICODE_STRING_SIMPLE("odd")
};
UnicodeString expFormatResult[][NUM_OF_FORMAT_ARGS] = {
{
UNICODE_STRING_SIMPLE("femValue"),
UNICODE_STRING_SIMPLE("even"),
UNICODE_STRING_SIMPLE("even")
},
{
UNICODE_STRING_SIMPLE("odd or even"),
UNICODE_STRING_SIMPLE("odd or even"),
UNICODE_STRING_SIMPLE("odd or even"),
},
{
UNICODE_STRING_SIMPLE("The number {0, number, integer} is even."),
UNICODE_STRING_SIMPLE("The number {0, number, integer} is even."),
UNICODE_STRING_SIMPLE("The number {0, number, integer} is odd."),
},
{
UNICODE_STRING_SIMPLE("The number {1} is even"),
UNICODE_STRING_SIMPLE("The number {1} is even"),
UNICODE_STRING_SIMPLE("The number {1} is odd"),
}
};
UnicodeString checkSyntaxData[SELECT_SYNTAX_DATA] = {
UNICODE_STRING_SIMPLE("odd{foo}"),
UNICODE_STRING_SIMPLE("*odd{foo} other{bar}"),
UNICODE_STRING_SIMPLE("odd{foo},other{bar}"),
UNICODE_STRING_SIMPLE("od d{foo} other{bar}"),
UNICODE_STRING_SIMPLE("odd{foo}{foobar}other{foo}"),
UNICODE_STRING_SIMPLE("odd{foo1}other{foo2}}"),
UNICODE_STRING_SIMPLE("odd{foo1}other{{foo2}"),
UNICODE_STRING_SIMPLE("odd{fo{o1}other{foo2}}")
};
UErrorCode status = U_ZERO_ERROR;
VERBOSE_USTRING(SIMPLE_PATTERN);
SelectFormat* selFmt = new SelectFormat( SIMPLE_PATTERN , status);
if (U_FAILURE(status)) {
dataerrln("ERROR: SelectFormat Unit Test constructor failed in unit tests.- exitting");
return;
}
// ======= Test SelectFormat pattern syntax.
logln("SelectFormat Unit Test : Testing SelectFormat pattern syntax.");
for (int32_t i=0; i<SELECT_SYNTAX_DATA; ++i) {
status = U_ZERO_ERROR;
VERBOSE_INT(i);
VERBOSE_USTRING(checkSyntaxData[i]);
selFmt->applyPattern(checkSyntaxData[i], status);
if (U_SUCCESS(status)){
errln("\nERROR: Unexpected result - SelectFormat Unit Test failed to detect syntax error with pattern: "+checkSyntaxData[i]);
}
}
// ICU 4.8 does not check for duplicate keywords any more.
status = U_ZERO_ERROR;
selFmt->applyPattern("odd{foo} odd{bar} other{foobar}", status);
FieldPosition format_ignore(FieldPosition::DONT_CARE);
UnicodeString format_result;
selFmt->format(UnicodeString("odd"), format_result, format_ignore, status);
assertEquals("should use first occurrence of the 'odd' keyword", "foo", format_result);
format_result.remove();
selFmt->applyPattern("odd{foo} other{bar} other{foobar}", status);
selFmt->format(UnicodeString("other"), format_result, format_ignore, status);
assertEquals("should use first occurrence of the 'other' keyword", "bar", format_result);
delete selFmt;
selFmt = NULL;
logln("SelectFormat Unit Test : Creating format object for Testing applying various patterns");
status = U_ZERO_ERROR;
selFmt = new SelectFormat( SIMPLE_PATTERN , status);
//SelectFormat* selFmt1 = new SelectFormat( SIMPLE_PATTERN , status);
if (U_FAILURE(status)) {
errln("ERROR: SelectFormat Unit Test constructor failed in unit tests.- exitting");
return;
}
// ======= Test applying and formatting with various pattern
logln("SelectFormat Unit test: Testing applyPattern() and format() ...");
UnicodeString result;
FieldPosition ignore(FieldPosition::DONT_CARE);
for(int32_t i=0; i<SELECT_PATTERN_DATA; ++i) {
status = U_ZERO_ERROR;
selFmt->applyPattern(patternTestData[i], status);
if (U_FAILURE(status)) {
errln("ERROR: SelectFormat Unit Test failed to apply pattern- "+patternTestData[i] );
continue;
}
//Format with the keyword array
for(int32_t j=0; j<3; j++) {
result.remove();
selFmt->format( formatArgs[j], result , ignore , status);
if (U_FAILURE(status)) {
errln("ERROR: SelectFormat Unit test failed in format() with argument: "+ formatArgs[j] + " and error is " + u_errorName(status) );
}else{
if( result != expFormatResult[i][j] ){
errln("ERROR: SelectFormat Unit test failed in format() with unexpected result\n with argument: "+ formatArgs[j] + "\n result obtained: " + result + "\n and expected is: " + expFormatResult[i][j] );
}
}
}
}
//Test with an invalid keyword
// one which contains Pattern_Syntax or Pattern_White_Space.
logln("SelectFormat Unit test: Testing format() with keyword method and with invalid keywords...");
status = U_ZERO_ERROR;
result.remove();
UnicodeString keywords[] = {
"9Keyword-_",
"-Keyword-_",
"_Keyword-_",
"\\u00E9Keyword-_",
"Key word-_",
" Keyword-_",
"Key*word-_",
"*Keyword-_"
};
delete selFmt;
selFmt = NULL;
selFmt = new SelectFormat( SIMPLE_PATTERN , status);
for (int32_t i = 0; i < UPRV_LENGTHOF(keywords); i++ ){
status = U_ZERO_ERROR;
selFmt->format( keywords[i], result , ignore , status);
if (!U_FAILURE(status)) {
errln("ERROR: SelectFormat Unit test failed in format() with keyWord and with an invalid keyword as : "+
keywords[i]+" ("+u_errorName(status)+")");
}
}
delete selFmt;
}
void SpellChecker::ignoreAll()
{
m_ignored.append(m_word);
ignore();
}
int get_robots_2d(struct coord *robot_pos, struct coord *points, int n){
//***************
// DECLARATIONS *
//***************
int group_index, valid_groups_counter = 0;
int i, j;
struct points_group points_group[MAX_GROUPS];
struct coord *groups_pos = NULL;
group_index = 0;
//********************************
// CREATION DE GROUPES DE POINTS *
//********************************
for(i=1; i<n; i++){//analyse des points
if(!ignore(points[i])){//si le point n'est pas à ignorer
if (dist(points[i], points[i-1]) < DIST_DIFF_GROUP) {
points_group[group_index].last = points[i];//on remplace le deuxième point par le dernier point détecté
points_group[group_index].size++; //il y un point de plus dans le groupe
}
else{ //Sinon on cree un nouveau groupe
group_index++;
points_group[group_index].first = points_group[group_index].last = points[i]; //on stocke le point dans un nouveau groupe de points
points_group[group_index].size = 1;//1 point dans ce groupe
points_group[group_index].valid = 0; //invalide par défaut
}
}
}
//*************************
// CALCUL DES COORDONNEES *
//*************************
for(i=0; i<group_index; i++){
points_group[i].coord.x = (points_group[i].first.x + points_group[i].last.x)/2;//X du robot
points_group[i].coord.y = (points_group[i].first.y + points_group[i].last.y)/2;//Y du robot
}
//*************************
// TRAITEMENT DES GROUPES *
//*************************
for(i=0; i<group_index;i++){
if(!group_exception(points_group[i])){
points_group[i].valid = 1;//si le point passe toutes les exceptions, il est valide
valid_groups_counter++;//un groupe valide de plus
}
}
//*************************
// COPIE DES GROUPES TEMP *
//*************************
groups_pos = (struct coord*)malloc(sizeof(struct coord) * valid_groups_counter); //il y aura une coordonnée par groupe valide
if(groups_pos == NULL){
fprintf(stderr, "groups_pos : malloc error");
exit(1);
}
j = 0;
for(i=0; i<group_index; i++){
if(points_group[i].valid == 1){//si le groupe est valide, on calcule ses coordonées
groups_pos[j] = points_group[i].coord;
j++;
}
}
//*****************************
// Copie des groupes finaux *
//*****************************
for(i=0; i<valid_groups_counter; i++){
robot_pos[i] = groups_pos[i];
}
return valid_groups_counter;
}
void print_empty_list (STREAM stream, D instance, BOOL escape_p, int print_depth) {
ignore(instance); ignore(escape_p); ignore(print_depth);
put_string("#()", stream);
}
GestureRecognizer::RecognizeFlag GestureRecognizerFlick::recognize(Gesture* ges,
MotionAction action, int num, float xs[], float ys[])
{
GestureRecognizer::RecognizeFlag retFlag = RecognizeFlag_Invaild;
GestureFlick* flick = static_cast<GestureFlick*>(ges);
if (!flick) return retFlag;
GestureState state = flick->state();
if (num == 0) {
return retFlag;
}
if (ignore()) {
if (maybeGesture) {
flick->clear();
}
return retFlag;
}
switch (action) {
case MotionAction_Down:
{
if (num == 1) {
maybeGesture = true;
flick->updateTrace(GesturePoint(xs[0], ys[0]), currentTime());
}
}
break;
case MotionAction_Up:
{
if (maybeGesture) {
flick->calcFlickInfo();
CCLOG("speed = %f ", flick->speed());
if (flick->speed() > S1) {
flick->setPoint(GesturePoint(xs[0], ys[0]));
flick->setState(GestureState_Triggered);
retFlag = RecognizeFlag_Triggered;
}
else {
flick->clear();
}
}
}
break;
case MotionAction_Pointer_Down:
case MotionAction_Pointer_Up:
{
setIgnore(true);
}
break;
case MotionAction_Move:
{
if (num == 1 && maybeGesture) {
flick->updateTrace(GesturePoint(xs[0], ys[0]), currentTime());
}
}
break;
default:
break;
}
return retFlag;
}
void print_symbol (STREAM stream, D instance, BOOL escape_p, int print_depth) {
ignore(escape_p);
put_string("#", stream);
print_symbol_name(stream, instance, TRUE, print_depth);
}
// FIXME this is currently invalid, but seems like it should be OK
// { dg-options -std=c++0x }
struct A { A() { } };
template<class T>
constexpr bool ignore(T&&) { return true; }
static_assert(ignore(10), "Error"); // OK
A s;
static_assert(ignore(s), "Error"); // Currently an error
void print_class (STREAM stream, D instance, BOOL escape_p, int print_depth) {
ignore(escape_p);
put_string("{class ", stream);
print_class_debug_name(stream, instance, TRUE, print_depth);
format(stream, " 0x%lx}", instance);
}
/**
* Get CRC of the data in the specified archive.
* Returns 0 if file could not be opened.
*/
unsigned int CArchiveScanner::GetCRC(const std::string& arcName)
{
CRC crc;
struct CRCPair {
std::string* filename;
unsigned int nameCRC;
unsigned int dataCRC;
};
// try to open an archive
std::unique_ptr<IArchive> ar(archiveLoader.OpenArchive(arcName));
if (ar == nullptr)
return 0;
// load ignore list, and insert all files to check in lowercase format
std::unique_ptr<IFileFilter> ignore(CreateIgnoreFilter(ar.get()));
std::vector<std::string> files;
std::vector<CRCPair> crcs;
files.reserve(ar->NumFiles());
crcs.reserve(ar->NumFiles());
for (unsigned fid = 0; fid != ar->NumFiles(); ++fid) {
const std::pair<std::string, int>& info = ar->FileInfo(fid);
if (ignore->Match(info.first))
continue;
// create case-insensitive hashes
files.push_back(StringToLower(info.first));
}
// sort by filename
std::stable_sort(files.begin(), files.end());
for (std::string& f: files) {
crcs.push_back(CRCPair{&f, 0, 0});
}
// compute CRCs of the files
// Hint: Multithreading only speedups `.sdd` loading. For those the CRC generation is extremely slow -
// it has to load the full file to calc it! For the other formats (sd7, sdz, sdp) the CRC is saved
// in the metainformation of the container and so the loading is much faster. Neither does any of our
// current (2011) packing libraries support multithreading :/
for_mt(0, crcs.size(), [&](const int i) {
CRCPair& crcp = crcs[i];
assert(crcp.filename == &files[i]);
const unsigned int nameCRC = CRC::GetCRC(crcp.filename->data(), crcp.filename->size());
const unsigned fid = ar->FindFile(*crcp.filename);
const unsigned int dataCRC = ar->GetCrc32(fid);
crcp.nameCRC = nameCRC;
crcp.dataCRC = dataCRC;
#if !defined(DEDICATED) && !defined(UNITSYNC)
Watchdog::ClearTimer(WDT_MAIN);
#endif
});
// Add file CRCs to the main archive CRC
for (const CRCPair& crcp: crcs) {
crc.Update(crcp.nameCRC);
crc.Update(crcp.dataCRC);
#if !defined(DEDICATED) && !defined(UNITSYNC)
Watchdog::ClearTimer();
#endif
}
// A value of 0 is used to indicate no crc.. so never return that
// Shouldn't happen all that often
const unsigned int digest = crc.GetDigest();
return (digest == 0)? 4711: digest;
}
D primitive_initialize_current_thread(D t, DBOOL s) {
ignore(s);
one_true_thread = t;
return(THREAD_SUCCESS);
}
streampos filebuf::seekoff(streamoff offset, _seek_dir dir, int mode)
{
streampos result, new_offset, delta;
_G_ssize_t count;
if (mode == 0) // Don't move any pointers.
dir = ios::cur, offset = 0;
// Flush unwritten characters.
// (This may do an unneeded write if we seek within the buffer.
// But to be able to switch to reading, we would need to set
// egptr to ptr. That can't be done in the current design,
// which assumes file_ptr() is eGptr. Anyway, since we probably
// end up flushing when we close(), it doesn't make much difference.)
if (pptr() > pbase() || put_mode())
if (switch_to_get_mode()) return EOF;
if (base() == NULL) {
doallocbuf();
setp(base(), base());
setg(base(), base(), base());
}
switch (dir) {
case ios::cur:
if (_fb._offset < 0) {
_fb._offset = sys_seek(0, ios::cur);
if (_fb._offset < 0)
return EOF;
}
// Make offset absolute, assuming current pointer is file_ptr().
offset += _fb._offset;
offset -= _egptr - _gptr;
if (in_backup())
offset -= _other_egptr - _other_gbase;
dir = ios::beg;
break;
case ios::beg:
break;
case ios::end:
struct stat st;
if (sys_stat(&st) == 0 && S_ISREG(st.st_mode)) {
offset += st.st_size;
dir = ios::beg;
}
else
goto dumb;
}
// At this point, dir==ios::beg.
// If destination is within current buffer, optimize:
if (_fb._offset >= 0 && _eback != NULL) {
// Offset relative to start of main get area.
fpos_t rel_offset = offset - _fb._offset
+ (eGptr()-Gbase());
if (rel_offset >= 0) {
if (in_backup())
switch_to_main_get_area();
if (rel_offset <= _egptr - _eback) {
setg(base(), base() + rel_offset, egptr());
setp(base(), base());
return offset;
}
// If we have streammarkers, seek forward by reading ahead.
if (have_markers()) {
int to_skip = rel_offset - (_gptr - _eback);
if (ignore(to_skip) != to_skip)
goto dumb;
return offset;
}
}
if (rel_offset < 0 && rel_offset >= Bbase() - Bptr()) {
if (!in_backup())
switch_to_backup_area();
gbump(_egptr + rel_offset - gptr());
return offset;
}
}
unsave_markers();
// Try to seek to a block boundary, to improve kernel page management.
new_offset = offset & ~(ebuf() - base() - 1);
delta = offset - new_offset;
if (delta > ebuf() - base()) {
new_offset = offset;
delta = 0;
}
result = sys_seek(new_offset, ios::beg);
if (result < 0)
return EOF;
if (delta == 0)
count = 0;
else {
count = sys_read(base(), ebuf()-base());
if (count < delta) {
// We weren't allowed to read, but try to seek the remainder.
offset = count == EOF ? delta : delta-count;
dir = ios::cur;
goto dumb;
}
}
setg(base(), base()+delta, base()+count);
setp(base(), base());
_fb._offset = result + count;
xflags(xflags() & ~ _S_EOF_SEEN);
return offset;
dumb:
unsave_markers();
result = sys_seek(offset, dir);
if (result != EOF) {
xflags(xflags() & ~_S_EOF_SEEN);
}
_fb._offset = result;
setg(base(), base(), base());
setp(base(), base());
return result;
}
D primitive_destroy_thread(D t) {
ignore(t);
return(THREAD_SUCCESS);
}
// The scanner. A tiny deterministic finite automaton.
int scan()
{
reset();
START:
switch (ch) {
case ' ': case '\t': case '\r':
ignore();
goto START;
case '-': case '+':
read();
return ADD_OP;
case '*': case '/':
read();
return MUL_OP;
case '(':
read();
return LEFT_PAREN;
case ')':
read();
return RIGHT_PAREN;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
read();
goto IN_LEADING_DIGITS;
case '\n':
ch = ' '; // delayed ignore()
return END_INPUT;
default:
error("bad character");
}
IN_LEADING_DIGITS:
switch (ch) {
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
read();
goto IN_LEADING_DIGITS;
case '.':
read();
goto IN_TRAILING_DIGITS;
default:
return NUMBER;
}
IN_TRAILING_DIGITS:
switch (ch) {
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
read();
goto IN_TRAILING_DIGITS;
default:
return NUMBER;
}
}
