char *gets(int channel, char *buf, uint32_t len) {
int ch;
uint32_t nread;
nread = 0;
while ((ch = Getc(channel))) {
if (ch == LF || ch == CR || ch == EOF) {
Putc(IO, '\n');
break;
} else if (ch == BS || ch == '\b') {
if (nread > 0) {
if (nread < len) {
buf--;
}
nread--;
bufputstr(IO, "\b \b");
}
} else {
if (nread < len) {
*buf++ = ch;
}
nread++;
Putc(IO, ch);
}
}
*buf = 0;
return buf;
}
int get_sensor(int unit, char buff[2]) {
Putc(COM1, 192+unit); //dump sensor unit memory into computer
buff[1] = Getc(COM1);
buff[2] = Getc(COM2);
Putc(COM1, 192); //reset sensor unit
return 0;
}
/* This function copies len characters from src to dst, possibly applying case conversions to them: if convertCase is 1, to upper case and if it is -1, to lower
* case. If convertNextOnly is 1, only a single character is converted (and convertCase is reset), otherwise all of them are. */
static void copy_with_maybe_case_conversion(String *dst, const char *src, int len, int *convertCase, int convertNextOnly)
{
/* Deal with the trivial cases first. */
if (!len)
return;
if (!*convertCase) {
Write(dst, src, len);
return;
}
/* If we must convert only the first character, do it and write the rest at once. */
if (convertNextOnly) {
int src_char = *src;
Putc(*convertCase == 1 ? toupper(src_char) : tolower(src_char), dst);
*convertCase = 0;
if (len > 1) {
Write(dst, src + 1, len - 1);
}
} else {
/* We need to convert all characters. */
int i;
for (i = 0; i < len; i++, src++) {
int src_char = *src;
Putc(*convertCase == 1 ? toupper(src_char) : tolower(src_char), dst);
}
}
}
String *Swig_string_escape(String *s) {
String *ns;
int c;
ns = NewStringEmpty();
while ((c = Getc(s)) != EOF) {
if (c == '\n') {
Printf(ns, "\\n");
} else if (c == '\r') {
Printf(ns, "\\r");
} else if (c == '\t') {
Printf(ns, "\\t");
} else if (c == '\\') {
Printf(ns, "\\\\");
} else if (c == '\'') {
Printf(ns, "\\'");
} else if (c == '\"') {
Printf(ns, "\\\"");
} else if (c == ' ') {
Putc(c, ns);
} else if (!isgraph(c)) {
if (c < 0)
c += UCHAR_MAX + 1;
Printf(ns, "\\%o", c);
} else {
Putc(c, ns);
}
}
return ns;
}
static void mangle_namestr(String *mangled, SwigType *t) {
int length = Len(t);
if (SwigType_isqualifier(t)) {
Append(mangled, "q_");
mangle_stringcopy(mangled, Char(t)+2, length-4);
Append(mangled, "__");
} else if (SwigType_ismemberpointer(t)) {
Append(mangled, "m_");
mangle_stringcopy(mangled, Char(t)+2, length-4);
Append(mangled, "__");
} else if (SwigType_isarray(t)) {
Append(mangled, "a_");
mangle_stringcopy(mangled, Char(t)+2, length-4);
Append(mangled, "__");
} else if (SwigType_isfunction(t)) {
List *p = SwigType_parmlist(t);
int sz = Len(p);
int i;
Append(mangled, "f_");
for (i = 0; i < sz; i++) {
mangle_subtype(mangled, Getitem(p, i));
Putc('_', mangled);
}
Append(mangled, (sz > 0) ? "_" : "__");
} else if (SwigType_isvarargs(t)) {
Append(mangled, "___");
} else {
char *d = Char(t);
char *c = strstr(d, "<(");
if (!c || !strstr(c + 2, ")>")) {
/* not a template type */
mangle_stringcopy(mangled, Char(t), Len(t));
} else {
/* a template type */
String *suffix;
List *p;
int i, sz;
mangle_stringcopy(mangled, d, c-d);
Putc('T', mangled);
Putc('_', mangled);
p = SwigType_parmlist(c + 1);
sz = Len(p);
for (i = 0; i < sz; i++) {
mangle_subtype(mangled, Getitem(p, i));
Putc('_', mangled);
}
Putc('t', mangled);
suffix = SwigType_templatesuffix(t);
if (Len(suffix) > 0) {
mangle_namestr(mangled, suffix);
} else {
Append(mangled, suffix);
}
Delete(suffix);
Delete(p);
}
}
}
void putw( int server, int channel, int n, char fc, char *bf ) {
char ch;
char *p = bf;
while( *p++ && n > 0 ) n--;
while( n-- > 0 ) Putc( server, channel, fc );
while( ( ch = *bf++ ) ) Putc( server, channel, ch );
}
static void
scanner_locator(String *loc) {
int c;
Locator *l;
Seek(loc,1,SEEK_SET);
c = Getc(loc);
if (c == '@') {
/* Empty locator. We pop the last location off */
if (locs) {
cparse_file = locs->filename;
cparse_line = locs->line_number;
l = locs->next;
free(locs);
locs = l;
}
/* Printf(stderr,"location: %s:%d\n",cparse_file,cparse_line);*/
return;
}
/* We're going to push a new location */
l = (Locator *) malloc(sizeof(Locator));
l->filename = cparse_file;
l->line_number = cparse_line;
l->next = locs;
locs = l;
/* Now, parse the new location out of the locator string */
{
String *fn = NewString("");
Putc(c,fn);
while ((c = Getc(loc)) != EOF) {
if ((c == '@') || (c == ',')) break;
Putc(c,fn);
}
cparse_file = Swig_copy_string(Char(fn));
Clear(fn);
cparse_line = 1;
/* Get the line number */
while ((c = Getc(loc)) != EOF) {
if ((c == '@') || (c == ',')) break;
Putc(c,fn);
}
cparse_line = atoi(Char(fn));
Clear(fn);
/* Get the rest of it */
while (( c= Getc(loc)) != EOF) {
if (c == '@') break;
Putc(c,fn);
}
/* Printf(stderr,"location: %s:%d\n",cparse_file,cparse_line); */
Delete(fn);
}
}
void trainSensorNotifier() {
int i;
int parent_tid = MyParentTid();
int com1_tid = WhoIs(COM1_REG_NAME);
int sensor_next = 0;
int data_changed = TRUE;
char query = SENSOR_READ_MULTI + SENSOR_DECODER_TOTAL;
SensorMsg msg;
msg.type = SENSOR_DATA;
for(i = 0; i < SENSOR_BYTES_TOTAL; i++) {
msg.sensor_data[i] = 0;
}
/* Filter out left over sensor data */
while(1) {
if(sensor_next == 0 && data_changed) {
Putc(com1_tid, query);
data_changed = 0;
}
else break;
int new_data = Getc(com1_tid);
assert(new_data >= 0, "Fail to get");
if(new_data != 0) data_changed = TRUE;
sensor_next = (sensor_next + 1) % SENSOR_BYTES_TOTAL;
}
data_changed = FALSE;
Putc(com1_tid, SENSOR_AUTO_RESET);
while(1) {
if(sensor_next == 0) {
if(data_changed) {
data_changed = FALSE;
// Deliver sensor data to the parent
Send(parent_tid, (char *)(&msg), SENSOR_BYTES_TOTAL, NULL, 0);
}
// Request sensor data again
Putc(com1_tid, query);
}
// Get and save new data
int new_data = Getc(com1_tid);
assert(new_data >= 0, "Fail to get");
if(msg.sensor_data[sensor_next] != new_data) {
msg.sensor_data[sensor_next] = new_data & 0xff;
data_changed = TRUE;
}
// Increment the counter
sensor_next = (sensor_next + 1) % SENSOR_BYTES_TOTAL;
}
}
void format ( int server, int channel, char *fmt, va_list va ) {
char bf[12];
char ch, lz;
int w;
while ( ( ch = *(fmt++) ) ) {
if ( ch != '%' )
Putc( server, channel, ch );
else {
lz = 0; w = 0;
ch = *(fmt++);
switch ( ch ) {
case '0':
lz = 1; ch = *(fmt++);
break;
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
ch = a2i( ch, &fmt, 10, &w );
break;
}
switch( ch ) {
case 0: return;
case 'c':
Putc( server, channel, va_arg( va, char ) );
break;
case 's':
putw( server, channel, w, 0, va_arg( va, char* ) );
break;
case 'u':
ui2a( va_arg( va, unsigned int ), 10, bf );
bwputw( channel, w, lz, bf );
break;
case 'd':
i2a( va_arg( va, int ), bf );
putw( server, channel, w, lz, bf );
break;
case 'x':
ui2a( va_arg( va, unsigned int ), 16, bf );
putw( server, channel, w, lz, bf );
break;
case '%':
Putc( server, channel, ch );
break;
}
}
}
}
int get_many_sensor(int num_of_units, char *buff, int *last_sensor_req_time, int *approx_hit_time) {
Putc(COM1, 128+num_of_units);
//Printf(COM2, "get_many_sensor: Sensors requested\n\r");
int i =0;
int sensor_req_time = Time();
for(i=0; i<2*num_of_units; i+=2) {
buff[i] = Getc(COM1);
buff[i+1] = Getc(COM1);
}
*approx_hit_time = ((*last_sensor_req_time + sensor_req_time + 1)/2);
Putc(COM1, 192);
*last_sensor_req_time = sensor_req_time;
return 0;
}
static word
do_write2(term_t stream, term_t term, int flags)
{ GET_LD
IOSTREAM *s;
if ( getTextOutputStream(stream, &s) )
{ write_options options;
int rc;
memset(&options, 0, sizeof(options));
options.flags = flags;
options.out = s;
options.module = MODULE_user;
if ( options.module
#ifndef __YAP_PROLOG__
&& True(options.module, M_CHARESCAPE)
#endif
)
options.flags |= PL_WRT_CHARESCAPES;
if ( truePrologFlag(PLFLAG_BACKQUOTED_STRING) )
options.flags |= PL_WRT_BACKQUOTED_STRING;
PutOpenToken(EOF, s); /* reset this */
rc = writeTopTerm(term, 1200, &options);
if ( rc && (flags&PL_WRT_NEWLINE) )
rc = Putc('\n', s);
return streamStatus(s) && rc;
}
return FALSE;
}
String *replace_captures(const char *input, String *subst, int captures[])
{
String *result = NewStringEmpty();
const char *p = Char(subst);
while (*p) {
/* Copy part without substitutions */
const char *q = strchr(p, '\\');
if (!q) {
Write(result, p, strlen(p));
break;
}
Write(result, p, q - p);
p = q + 1;
/* Handle substitution */
if (*p == '\0') {
Putc('\\', result);
} else if (isdigit(*p)) {
int group = *p++ - '0';
int l = captures[group*2], r = captures[group*2 + 1];
if (l != -1) {
Write(result, input + l, r - l);
}
}
}
return result;
}
String *replace_captures(int num_captures, const char *input, String *subst, int captures[], String *pattern, String *s)
{
String *result = NewStringEmpty();
const char *p = Char(subst);
while (*p) {
/* Copy part without substitutions */
const char *q = strchr(p, '\\');
if (!q) {
Write(result, p, strlen(p));
break;
}
Write(result, p, q - p);
p = q + 1;
/* Handle substitution */
if (*p == '\0') {
Putc('\\', result);
} else if (isdigit((unsigned char)*p)) {
int group = *p++ - '0';
if (group < num_captures) {
int l = captures[group*2], r = captures[group*2 + 1];
if (l != -1) {
Write(result, input + l, r - l);
}
} else {
Swig_error("SWIG", Getline(s), "PCRE capture replacement failed while matching \"%s\" using \"%s\" - request for group %d is greater than the number of captures %d.\n",
Char(pattern), input, group, num_captures-1);
}
}
}
return result;
}
String *Swig_string_first_lower(String *s) {
String *ns = NewStringEmpty();
char *cs = Char(s);
if (cs && cs[0] != 0) {
Putc(tolower((int)cs[0]), ns);
Append(ns, cs + 1);
}
return ns;
}
static int
PutOpenToken(int c, IOSTREAM *s)
{ if ( needSpace(c, s) )
{ TRY(Putc(' ', s));
return TRUE_WITH_SPACE;
}
return TRUE;
}
/* Alternative implementation for manglestr_default. Mangling is similar to the original
except for a few subtle differences for example in templates:
namespace foo {
template<class T> class bar {};
typedef int Integer;
void test2(bar<Integer *> *x);
}
Mangling is more consistent and changes from
_p_foo__barT_int_p_t to
_p_foo__barT_p_int_t.
*/
static void mangle_stringcopy(String *destination, const char *source, int count) {
while (count-- > 0) {
char newc = '_';
if (!(*source == '.' || *source == ':' || *source == ' '))
newc = *source;
/* TODO: occasionally '*' or numerics need converting to '_', eg in array dimensions and template expressions */
Putc(newc, destination);
source++;
}
}
String *Swig_string_upper(String *s) {
String *ns;
int c;
ns = NewString("");
while ((c = Getc(s)) != EOF) {
Putc(toupper(c),ns);
}
return ns;
}
String *Swig_string_lower(String *s) {
String *ns;
int c;
ns = NewStringEmpty();
Seek(s, 0, SEEK_SET);
while ((c = Getc(s)) != EOF) {
Putc(tolower(c), ns);
}
return ns;
}
void train_code(){
char tr_speeds [NUM_TRAINS];
// initialization
int i;
for (i = 0; i < NUM_TRAINS; i++){
tr_speeds[i] = 0;
}
char stop[3];
char rcv_buff[3];
stop[0] = stop[1] = stop[2] = rcv_buff[0] = rcv_buff[1] = rcv_buff[2] = 0;
char reply_buff = 0;
int prompt_tid;
while(1){
// Need to receive 2 bytes for the train command
Receive(&prompt_tid, &rcv_buff, 2*sizeof(char));
if (rcv_buff[0] == 15){ // Reversing
stop[1] = rcv_buff[1]; // train number
Putc(COM1, 0); Putc(COM1, stop[1]); // Stop
Reply(prompt_tid, &reply_buff, sizeof(char));
Delay(200);
Putstr(COM1, rcv_buff); // Reverse
rcv_buff[0] = tr_speeds[rcv_buff[1]-1]; // stored speed of the train
Putstr(COM1, rcv_buff); // Set speed
}
else if(rcv_buff[0] == 0){
tr_speeds[rcv_buff[1]-1] = 0;
Putc(COM1, 0); Putc(COM1, rcv_buff[1]);
Reply(prompt_tid, &reply_buff, sizeof(char));
}
else { // Setting speed
tr_speeds[rcv_buff[1]-1] = rcv_buff[0];
Putstr(COM1, rcv_buff);
Reply(prompt_tid, &reply_buff, sizeof(char));
}
}
Exit();
kprintf("Unexpected return from Exit() at train_code\n\r");
}
String *Swig_string_title(String *s) {
String *ns;
int first = 1;
int c;
ns = NewString("");
while ((c = Getc(s)) != EOF) {
Putc(first ? toupper(c) : tolower(c),ns);
first = 0;
}
return ns;
}
String *Swig_string_title(String *s) {
String *ns;
int first = 1;
int c;
ns = NewStringEmpty();
Seek(s, 0, SEEK_SET);
while ((c = Getc(s)) != EOF) {
Putc(first ? toupper(c) : tolower(c), ns);
first = 0;
}
return ns;
}
static void sensorQueryWorker() {
char com1Name[] = IOSERVERCOM1_NAME;
int com1 = WhoIs(com1Name);
int parent = MyParentsTid();
for (;;) {
SensorMsg msg;
msg.type = QUERY_WORKER;
Send(parent, (char *)&msg, sizeof(SensorMsg), (char *)NULL, 0);
Putc(com1, 133);
}
}
void user(void) {
Putc(COM2, 'u');
Putc(COM1, 0x61);
Putc(COM1, 0x60);
Putc(COM1, 0x61);
Putc(COM1, 0x60);
Putc(COM1, 0x61);
Putc(COM1, 0x60);
Exit();
}
String *Swig_string_lccase(String *s) {
String *ns;
int first = 1;
int after_underscore = 0;
int c;
ns = NewStringEmpty();
Seek(s, 0, SEEK_SET);
while ((c = Getc(s)) != EOF) {
if (c == '_') {
after_underscore = 1;
continue;
}
if (first) {
Putc(tolower(c), ns);
first = 0;
} else {
Putc(after_underscore ? toupper(c) : c, ns);
}
after_underscore = 0;
}
return ns;
}
String *Swig_string_ucase(String *s) {
String *ns;
int c;
int lastC = 0;
int nextC = 0;
int underscore = 0;
ns = NewStringEmpty();
/* We insert a underscore when:
1. Lower case char followed by upper case char
getFoo > get_foo; getFOo > get_foo; GETFOO > getfoo
2. Number proceded by char and not end of string
get2D > get_2d; get22D > get_22d; GET2D > get_2d
but:
asFloat2 > as_float2
*/
Seek(s, 0, SEEK_SET);
while ((c = Getc(s)) != EOF) {
nextC = Getc(s); Ungetc(nextC, s);
if (isdigit(c) && isalpha(lastC) && nextC != EOF)
underscore = 1;
else if (isupper(c) && isalpha(lastC) && !isupper(lastC))
underscore = 1;
lastC = c;
if (underscore) {
Putc('_', ns);
underscore = 0;
}
Putc(tolower(c), ns);
}
return ns;
}
static void near BadBarPwd(char *pwd, char *name, int tries)
{
logit(log_bad_bar_pwd, name, pwd);
Printf(wrong_pwd, tries);
Putc('\n');
if (tries==3)
{
logit(l_invalid_pwd);
Puts(invalid_pwd);
ci_barricade();
mdm_hangup();
}
}
/* Returns the function type, t, constructed from the parameters, parms */
SwigType *SwigType_add_function(SwigType *t, ParmList *parms) {
String *pstr;
Parm *p;
Insert(t, 0, ").");
pstr = NewString("f(");
for (p = parms; p; p = nextSibling(p)) {
if (p != parms)
Putc(',', pstr);
Append(pstr, Getattr(p, "type"));
}
Insert(t, 0, pstr);
Delete(pstr);
return t;
}
String *Swig_string_ccase(String *s) {
String *ns;
int first = 1;
int c;
ns = NewStringEmpty();
Seek(s, 0, SEEK_SET);
while ((c = Getc(s)) != EOF) {
if (c == '_') {
first = 1;
continue;
}
Putc(first ? toupper(c) : c, ns);
first = 0;
}
return ns;
}
static void DumpSysVar(char const *name, const SysVar *v)
{
char buffer[VAR_NAME_LEN+10];
if (name && !*name) name=NULL;
if (!v && !name) return; /* Shouldn't happen... */
buffer[0]='$'; buffer[1] = 0;
if (name) strcat(buffer, name); else strcat(buffer, v->name);
fprintf(ErrFp, "%*s ", VAR_NAME_LEN+1, buffer);
if (v) {
if (v->type == SPECIAL_TYPE) {
Value val;
SysVarFunc f = (SysVarFunc) v->value;
f(0, &val);
PrintValue(&val, ErrFp);
Putc('\n', ErrFp);
DestroyValue(val);
} else if (v->type == STR_TYPE) {
char const *s = *((char **)v->value);
int y;
Putc('"', ErrFp);
for (y=0; y<MAX_PRT_LEN && *s; y++) {
if (*s == '"') {
fprintf(ErrFp, "\" + char(34) + \"");
s++;
} else {
Putc(*s++, ErrFp);
}
}
Putc('"', ErrFp);
if (*s) fprintf(ErrFp, "...");
Putc('\n', ErrFp);
} else if (v->type == DATE_TYPE) {
Value val;
val.type = DATE_TYPE;
val.v.val = * (int *) v->value;
PrintValue(&val, ErrFp);
Putc('\n', ErrFp);
} else {
if (!v->modifiable) fprintf(ErrFp, "%d\n", *((int *)v->value));
else {
fprintf(ErrFp, "%-10d ", *((int *)v->value));
if (v->min == ANY) fprintf(ErrFp, "(-Inf, ");
else fprintf(ErrFp, "[%d, ", v->min);
if (v->max == ANY) fprintf(ErrFp, "Inf)\n");
else fprintf(ErrFp, "%d]\n", v->max);
}
}
} else fprintf(ErrFp, "%s\n", UNDEF);
return;
}
/* -----------------------------------------------------------------------------
* nextchar()
*
* Returns the next character from the scanner or 0 if end of the string.
* ----------------------------------------------------------------------------- */
static char nextchar(Scanner *s) {
int nc;
if (!s->str)
return 0;
while ((nc = Getc(s->str)) == EOF) {
Delete(s->str);
s->str = 0;
Delitem(s->scanobjs, 0);
if (Len(s->scanobjs) == 0)
return 0;
s->str = Getitem(s->scanobjs, 0);
s->line = Getline(s->str);
DohIncref(s->str);
}
if ((nc == '\n') && (!s->freeze_line))
s->line++;
Putc(nc,s->text);
return (char)nc;
}
