void LanguagePack::ParseLine(IStringReader *reader)
{
SkipWhitespace(reader);
codepoint_t codepoint;
if (reader->TryPeek(&codepoint))
{
switch (codepoint) {
case '#':
SkipToEndOfLine(reader);
break;
case '[':
ParseGroupObject(reader);
break;
case '<':
ParseGroupScenario(reader);
break;
case '\r':
case '\n':
break;
default:
ParseString(reader);
break;
}
SkipToEndOfLine(reader);
SkipNewLine(reader);
}
}
static void ReadMatData(
Shape& mat, // out
int nrows, // in
int ncols, // in
FILE* file, // in
const char* path) // in: for error reporting
{
double* data = Buf(mat);
for (int i = 0; i < ncols * nrows; i++)
{
// skip comments and white space
int c = ' ';
while (c == ' ' || c == '\t' || c == '\n' || c == '\r')
{
c = fgetc(file);
if (c == '#') // comment
{
SkipToEndOfLine(file, path);
c = fgetc(file);
}
}
if (c == EOF)
PrematureEndOfFile(file, path);
else
{
ungetc(c, file);
float temp; // microsoft compiler can't sscanf doubles so use float
if (!fscanf(file, "%g", &temp))
Err("%s(%d): Cannot read %dx%d matrix",
path, LineNbr(file), nrows, ncols);
data[i] = temp;
}
}
}
void ReadInputNetwork()
{ int i, j, node;
FILE *inp;
if (NULL == (inp = fopen(INPUT_FILE_NAME, "r"))) { printf("error in opening %s\n", INPUT_FILE_NAME); exit(1); }
fscanf(inp, "%s", networkName, inp); SkipToEndOfLine(inp);
fscanf(inp, "%d", &numNodes); SkipToEndOfLine(inp);
degrees = (int *)malloc(numNodes * sizeof(int));
adjNodes = (int **)calloc(numNodes, sizeof(int *));
adjNodePositions = (int **)malloc(numNodes * sizeof(int *));
for (i=0; i<numNodes; i++) {
fscanf(inp, "%d ", &node); fscanf(inp, "(%d):", °rees[node]);
adjNodes[node] = (int *)malloc(degrees[node] * sizeof(int)); // variably sized array of int arrays
adjNodePositions[node] = (int *)malloc(numNodes * sizeof(int)); // numNodes x numNodes
for (j=0; j<degrees[node]; j++)
{ fscanf(inp, "%d", &adjNodes[node][j]); // tracks jth neighbor of node (variably sized)
adjNodePositions[node][adjNodes[node][j]] = j; // given node and neighbor j, returns j's index in *adjNodes[node]
}
SkipToEndOfLine(inp);
}
fscanf(inp, "%d %d %d %d %lf %lf", &source, &sourceTTL, &maxDestNodeTTL, &numPackets, &probSuccTransm, &RRTdelayFactor);
SkipToEndOfLine(inp);
fscanf(inp, "%d", &numPSFQruns); SkipToEndOfLine(inp);
fscanf(inp, "%d %d %d %d", &RRT_YES_NO, &NEED_NODETTL_POSITIVE_FOR_T_AND_RT, &PRINT_DETAILS, &STEP_EACH_TIME_POINT); SkipToEndOfLine(inp);
SkipToEndOfLine(inp); //keep this; datafile has an extra line before next input PRINT_JUST_FINAL_TOTALS
if (1 == STEP_EACH_TIME_POINT) PRINT_DETAILS = 1;
fscanf(inp, "%d", &PRINT_JUST_FINAL_TOTALS); SkipToEndOfLine(inp);
if (1 == PRINT_JUST_FINAL_TOTALS) PRINT_DETAILS = STEP_EACH_TIME_POINT = 0;
fscanf(inp, "%d", &PRINT_TIME_PROFILE_ONE_ITEM_PER_LINE); SkipToEndOfLine(inp);
fclose(inp);
//print input data
printf("networkName: %s, numNodes=%d, source=%d, sourceTTL=%d, maxDestNodeTTL=%d, numPackets=%d, probSuccTransm=%0.2f, numPSFQruns=%d,\n",
networkName, numNodes, source, sourceTTL, maxDestNodeTTL, numPackets, probSuccTransm, numPSFQruns);
printf(" : RRTdelayFactor=%0.2f\n", RRTdelayFactor);
for (i=0; i<numNodes; i++) {
printf("%2d(%2d):", i, degrees[i]);
for (j=0; j<degrees[i]; j++)
printf(" %d", adjNodes[i][j]);
printf("\n");
}
printf("numPSFQruns(includes unsuccessful runs, if any)=%d\n", numPSFQruns); printf("-----------------------------------\n");
}
static bool ReadMat( // true if read the mat, false if no (more) mats in file
char* base, // out: basename in tag
unsigned& bits, // out: hex bits in tag
Shape& mat, // out: the matrix
FILE* file, // in: pointer to the shape file
const char* path) // in: for error messages
{
char s[SLEN]; // the string tag before the matrix
while (1)
{
int c = fgetc(file);
if (c == EOF)
return false; // note return
if (c == '{')
break; // note break
else if (c == '#')
SkipToEndOfLine(file, path);
else if (c == '\n' || c == '\r' || c == '\t' || c == ' ') // white space
;
else if (c == '"') // old format tag (enclosed in quotes)
;
else // any other char, assume it is the start of the tag
{
s[0] = char(c);
if (!Fgets(s+1, SLEN-1, file))
Err("%s(%d): Read failed (premature EOF)",
path, LineNbr(file));
// remove trailing white space and final quote if any
int i = STRNLEN(s, SLEN) - 1;
CV_Assert(i >= 4);
while (s[i] == ' ' || s[i] == '\t' || s[i] == '"')
i--;
s[i+1] = 0;
}
}
if (!s[0])
Err("%s(%d): Empty tag", path, LineNbr(file));
if (s[4] != ' ' && s[8] != ' ') // hex string must be 4 or 8 chars
Err("%s(%d): Malformed tag", path, LineNbr(file));
if (2 != sscanf(s, "%x %s", &bits, base))
Err("%s(%d): Malformed tag", path, LineNbr(file));
int nrows, ncols; int c;
if (2 != fscanf(file, "%d %d", &nrows, &ncols))
Err("%s(%d): Cannot read matrix size", path, LineNbr(file));
if (ncols < 1 || nrows > MAX_MAT_DIM)
Err("%s(%d): Invalid number of rows %d", path, LineNbr(file), nrows);
if (ncols < 1 || ncols > MAX_MAT_DIM)
Err("%s(%d): Invalid number of columns %d", path, LineNbr(file), ncols);
mat.create(nrows, ncols);
ReadMatData(mat, nrows, ncols, file, path);
// make sure that next non-white char is matrix terminator '}'
c = ' ';
while (c == ' ' || c == '\t' || c == '\n' || c == '\r') // skip white space
if (EOF == (c = fgetc(file))) // assignment is intentional
Err("%s(%d): Cannot read matrix\n"
" Reached EOF before finding \"}\"",
path, LineNbr(file));
if (c == '#')
Err("%s(%d): Comment not allowed here", path, LineNbr(file));
if (c != '}')
Err("%s(%d): Footer is not \"}\" "
"(too many or two few entries in matrix?)", path, LineNbr(file));
return true; // success
}
NNT Lexer::NextOperator() {
switch (*cursor) {
case '`': IncrementCursor(); RETURN_NNT("`", op_bl, 1);
case '@': IncrementCursor(); RETURN_NNT("@", op_l, 1);
case ',': IncrementCursor(); RETURN_NNT(",", comma, 1);
case ';': IncrementCursor(); RETURN_NNT(";", semicolon, 1);
case '(': IncrementCursor(); RETURN_NNT("(", l_paren, 1);
case ')': IncrementCursor(); RETURN_NNT(")", r_paren, 1);
case '[': IncrementCursor(); RETURN_NNT("[", l_bracket, 1);
case ']': IncrementCursor(); RETURN_NNT("]", r_bracket, 1);
case '{': IncrementCursor(); RETURN_NNT("{", l_brace, 1);
case '}': IncrementCursor(); RETURN_NNT("}", r_brace, 1);
case '$': IncrementCursor(); RETURN_NNT("$", op_l, 1);
case '.': {
Cursor cursor_copy = cursor;
// Note: safe because we know we have a null-terminator
while (*cursor == '.') { IncrementCursor(); }
size_t num_dots = cursor.offset - cursor_copy.offset;
if (num_dots == 1) {
RETURN_NNT(".", op_b, 1);
} else {
if (num_dots > 2) { ErrorLog::TooManyDots(cursor_copy, num_dots); }
RETURN_NNT("..", dots, 2);
}
} break;
case '\\': {
Cursor cursor_copy = cursor;
size_t dist = 1;
IncrementCursor();
++dist;
switch(*cursor) {
case '\\':
IncrementCursor();
RETURN_NNT("", newline, 0);
break;
case '\0':
// Ignore the following newline
IncrementCursor();
return Next();
case ' ':
case '\t':
while (IsWhitespace(*cursor)) {
IncrementCursor();
++dist;
}
if (*cursor == '\0') {
IncrementCursor();
return Next();
}
// Intentionally falling through. Looking at a non-whitespace after a '\'
default:
ErrorLog::NonWhitespaceAfterNewlineEscape(cursor_copy, dist);
return Next();
}
} break;
case '#': {
IncrementCursor();
Cursor cursor_copy = cursor;
if (!IsAlpha(*cursor)) {
ErrorLog::InvalidHashtag(cursor_copy);
return Next();
}
do { IncrementCursor(); } while (IsAlphaNumericOrUnderscore(*cursor));
if (cursor.offset - cursor_copy.offset == 0) {
ErrorLog::InvalidHashtag(cursor_copy);
}
char old_char = *cursor;
*cursor = '\0';
const char *tag_ref = cursor.line.ptr + cursor_copy.offset;
size_t tag_len = strlen(tag_ref);
char *tag = new char[tag_len + 1];
strcpy(tag, tag_ref);
*cursor = old_char;
RETURN_NNT(tag, hashtag, tag_len + 1);
} break;
case '+':
case '%':
case '<':
case '>':
case '|':
case '^': {
char first_char = *cursor;
IncrementCursor();
char *token = new char[3];
token[0] = first_char;
if (*cursor == '=') {
IncrementCursor();
token[1] = '=';
} else {
token[1] = '\0';
}
token[2] = '\0';
RETURN_NNT(token, op_b, strlen(token));
} break;
case '*':
IncrementCursor();
if (*cursor == '/') {
IncrementCursor();
if (*cursor == '/') {
// Looking at "*//" which should be parsed as an asterisk followed by a
// one-line comment.
BackUpCursor();
RETURN_NNT("*", op_b, 1);
} else {
Cursor cursor_copy = cursor;
cursor_copy.offset -= 2;
ErrorLog::NotInMultilineComment(cursor_copy);
return Next();
}
} else if (*cursor == '=') {
IncrementCursor();
RETURN_NNT("*=", op_b, 2);
} else {
RETURN_NNT("*", op_b, 1);
}
case '&': {
IncrementCursor();
if (*cursor == '=') {
IncrementCursor();
RETURN_NNT("&=", op_b, 2);
} else {
RETURN_NNT("&", op_bl, 1);
}
} break;
case ':': {
IncrementCursor();
if (*cursor == '=') {
IncrementCursor();
RETURN_NNT(":=", op_b, 2);
} else if (*cursor == '>') {
IncrementCursor();
RETURN_NNT(":>", op_b, 2);
} else {
RETURN_NNT(":", colon, 1);
}
} break;
case '!': {
IncrementCursor();
if (*cursor == '=') {
IncrementCursor();
RETURN_NNT("!=", op_b, 2);
} else {
RETURN_NNT("!", op_l, 1);
}
} break;
case '-': {
IncrementCursor();
if (*cursor == '=') {
IncrementCursor();
RETURN_NNT("-=", op_b, 2);
} else if (*cursor == '>') {
IncrementCursor();
auto nptr = new AST::TokenNode(cursor, "->");
nptr->op = Language::Operator::Arrow;
return NNT(nptr, Language::fn_arrow);
} else if (*cursor == '-') {
IncrementCursor();
RETURN_TERMINAL(Hole, Unknown, IR::Value::None());
} else {
RETURN_NNT("-", op_bl, 1);
}
} break;
case '=': {
IncrementCursor();
if (*cursor == '=') {
IncrementCursor();
RETURN_NNT("==", op_b, 2);
} else if (*cursor == '>') {
IncrementCursor();
RETURN_NNT("=>", op_b, 2);
} else {
RETURN_NNT("=", eq, 1);
}
} break;
case '/': {
IncrementCursor();
if (*cursor == '/') {
// Ignore comments altogether
SkipToEndOfLine();
return Next();
} else if (*cursor == '=') {
IncrementCursor();
RETURN_NNT("/=", op_b, 2);
} else if (*cursor == '*') {
IncrementCursor();
char back_one = *cursor;
IncrementCursor();
size_t comment_layer = 1;
while (comment_layer != 0) {
if (ifs.eof()) {
ErrorLog::RunawayMultilineComment();
RETURN_NNT("", eof, 0);
} else if (back_one == '/' && *cursor == '*') {
++comment_layer;
} else if (back_one == '*' && *cursor == '/') {
--comment_layer;
}
back_one = *cursor;
IncrementCursor();
}
// Ignore comments altogether
return Next();
} else {
RETURN_NNT("/", op_b, 1);
}
} break;
case '"': {
IncrementCursor();
std::string str_lit = "";
while (*cursor != '"' && *cursor != '\0') {
if (*cursor == '\\') {
IncrementCursor();
switch (*cursor) {
case '\'': {
str_lit += '\'';
Cursor cursor_copy = cursor;
--cursor_copy.offset;
ErrorLog::EscapedSingleQuoteInStringLit(cursor_copy);
} break;
case '\\': str_lit += '\\'; break;
case '"': str_lit += '"'; break;
case 'a': str_lit += '\a'; break;
case 'b': str_lit += '\b'; break;
case 'f': str_lit += '\f'; break;
case 'n': str_lit += '\n'; break;
case 'r': str_lit += '\r'; break;
case 't': str_lit += '\t'; break;
case 'v': str_lit += '\v'; break;
default: {
Cursor cursor_copy = cursor;
--cursor_copy.offset;
ErrorLog::InvalidEscapeCharInStringLit(cursor_copy);
str_lit += *cursor;
} break;
}
} else {
str_lit += *cursor;
}
IncrementCursor();
}
if (*cursor == '\0') {
ErrorLog::RunawayStringLit(cursor);
} else {
IncrementCursor();
}
// Not leaked. It's owned by a terminal which is persistent.
char *cstr = new char[str_lit.size() + 2];
strcpy(cstr + 1, str_lit.c_str());
cstr[0] = '\1';
RETURN_TERMINAL(StringLiteral, String, IR::Value(cstr));
} break;
case '\'': {
IncrementCursor();
char result;
switch (*cursor) {
case '\t':
ErrorLog::TabInCharLit(cursor);
result = '\t';
break;
case '\0': {
ErrorLog::RunawayCharLit(cursor);
RETURN_TERMINAL(Char, Char, IR::Value::Char('\0'));
}
case '\\': {
IncrementCursor();
switch (*cursor) {
case '\"': {
result = '"';
Cursor cursor_copy = cursor;
--cursor_copy.offset;
ErrorLog::EscapedDoubleQuoteInCharLit(cursor_copy);
} break;
case '\\': result = '\\'; break;
case '\'': result = '\''; break;
case 'a': result = '\a'; break;
case 'b': result = '\b'; break;
case 'f': result = '\f'; break;
case 'n': result = '\n'; break;
case 'r': result = '\r'; break;
case 't': result = '\t'; break;
case 'v': result = '\v'; break;
default:
Cursor cursor_copy = cursor;
--cursor_copy.offset;
ErrorLog::InvalidEscapeCharInCharLit(cursor_copy);
result = *cursor;
}
break;
}
default: { result = *cursor; } break;
}
IncrementCursor();
if (*cursor == '\'') {
IncrementCursor();
} else {
ErrorLog::RunawayCharLit(cursor);
}
RETURN_TERMINAL(Char, Char, IR::Value::Char(result));
} break;
case '?':
ErrorLog::InvalidCharQuestionMark(cursor);
IncrementCursor();
return Next();
case '~':
ErrorLog::InvalidCharTilde(cursor);
IncrementCursor();
return Next();
case '_': UNREACHABLE;
default: UNREACHABLE;
}
}
