gint testMorePushPop(autounit_test_t *t) {
QueryNode queryNode[10];
QueryNode tmp;
queryNode[0].operator = QPP_OP_AND;
queryNode[1].operator = QPP_OP_OR;
queryNode[1].num_of_operands = 2;
queryNode[2].operator = QPP_OP_STAR;
queryNode[2].num_of_operands = 1;
queryNode[2].opParam = STAR_BEGIN;
queryNode[3].operator = QPP_OP_BEG_PHRASE;
queryNode[4].operator = -1;
queryNode[4].wordid = 4;
queryNode[5].operator = QPP_OP_END_PHRASE;
queryNode[6].operator = -1;
queryNode[6].wordid = 6;
stk_init(&stack);
for (i = 0; i<7; i++)
stk_push(&stack,&(queryNode[i]) );
stk_pop(&stack,&tmp);
au_assert(t,"",tmp.operator == -1);
au_assert(t,"",tmp.wordid == 6);
stk_pop(&stack,&tmp);
au_assert(t,"",tmp.operator == QPP_OP_END_PHRASE);
stk_pop(&stack,&tmp);
au_assert(t,"",tmp.operator == -1);
au_assert(t,"",tmp.wordid == 4);
stk_pop(&stack,&tmp);
au_assert(t,"",tmp.operator == QPP_OP_BEG_PHRASE);
stk_pop(&stack,&tmp);
au_assert(t,"",tmp.operator == QPP_OP_STAR);
au_assert(t,"",tmp.num_of_operands == 1);
au_assert(t,"",tmp.opParam == STAR_BEGIN);
stk_pop(&stack,&tmp);
au_assert(t,"",tmp.operator == QPP_OP_OR);
au_assert(t,"",tmp.num_of_operands == 2);
stk_pop(&stack,&tmp);
au_assert(t,"",tmp.operator == QPP_OP_AND);
nRet = stk_pop(&stack,&tmp);
au_assert(t,"",nRet == STACK_UNDERFLOW);
return TRUE;
}
void calc_clear(stk_t * s)
{
if( s == NULL)
return;
while( ! stk_is_empty(s) )
stk_pop(s);
}
void elg_readcb_OMP_COLLEXIT(elg_ui4 lid, elg_d8 time,
elg_ui1 metc, elg_ui8 metv[], void* userdata) {
StackNode *n;
lid = locmap[lid];
n = stk_pop(lid);
if ( genompglop && is_glop(n->reg) ) {
elg_d8 stime = (n->tim)*1.0e+10+1.0;
elg_d8 etime = time*1.0e+10-1.0;
if ( etime <= stime ) {
stime = (n->tim)*1.0e+10;
etime = time*1.0e+10;
}
wbytes += VTF3_WriteGlobalop(fcb, stime, n->reg,
(unsigned int) lid,
/*com*/ maxcomm + 1 + loctab[lid].proc->id,
/*root*/ -1, /*sent*/ 0, /*recvd*/ 0,
etime-stime, VTF3_SCLNONE);
}
if ( writeOMP ) {
wbytes += VTF3_WriteOpenmpleave(fcb, time*1.0e+10, (unsigned int) lid,
scl_of_state(n->reg));
} else {
wbytes += VTF3_WriteUpfrom(fcb, time*1.0e+10, n->reg, (unsigned int) lid,
VTF3_SCLNONE);
}
genWriteCOUNTER(lid, time, metc, metv);
}
gint testErrors(autounit_test_t *t) {
QueryNode tmp;
stk_init(&stack);
nRet = stk_pop(&stack,&tmp);
au_assert(t,"",nRet == STACK_UNDERFLOW);
return TRUE;
}
void elg_readcb_OMP_JOIN(elg_ui4 lid, elg_d8 time, void* userdata) {
MYDATA* md = (MYDATA*) userdata;
StackNode *n;
int i;
struct {
int16_t length;
char *string;
} val;
lid = locmap[lid];
n = stk_pop(lid);
#ifdef DEBUG
printf("OMP Join on %d, %d, %s\n",lid, n->reg, statetab[n->reg].name);
#endif
if(primitives == NULL) {
primitives = (PRIMITIVES_List*) malloc(sizeof(struct _primitives_list));
last_primitive = primitives;
primitives->size = 0;
} else {
last_primitive->next = (PRIMITIVES_List*) malloc(sizeof(struct _primitives_list));
last_primitive = last_primitive->next;
}
/* New Event */
primitives->size++;
last_primitive->next = NULL;
last_primitive->prim = (DRAW_Primitive *) malloc(sizeof(DRAW_Primitive));
last_primitive->prim->starttime = n->tim;
last_primitive->prim->endtime = time;
last_primitive->prim->type_idx = ST_OMP;
last_primitive->prim->num_tcoords = 2;
last_primitive->prim->tcoords = (double*) malloc(2*sizeof(double));
last_primitive->prim->tcoords[0] = n->tim;
last_primitive->prim->tcoords[1] = time;
last_primitive->prim->num_ycoords = 2;
last_primitive->prim->ycoords = (int*) malloc(2*sizeof(int));
last_primitive->prim->ycoords[0] = lid;
last_primitive->prim->ycoords[1] = lid;
last_primitive->prim->num_info = sizeof(int16_t)+6*sizeof(char);
last_primitive->prim->info = (char*) malloc(last_primitive->prim->num_info*sizeof(char));
val.string = (char *) malloc(6*sizeof(char));
strcpy(val.string, "OpenMP");
val.length = strlen("OpenMP");
if(ELG_BYTE_ORDER == ELG_LITTLE_ENDIAN) {
elg_swap(&val.length, sizeof(int16_t));
}
memcpy(last_primitive->prim->info, &val.length, sizeof(int16_t));
memcpy(last_primitive->prim->info+sizeof(int16_t), val.string, 6*sizeof(char));
}
void elg_readcb_MPI_WINEXIT(elg_ui4 lid, elg_d8 time,
elg_ui1 metc, elg_ui8 metv[], elg_ui4 wid, elg_ui4 cid, elg_ui1 synex,
void* userdata) {
StackNode *n;
lid = locmap[lid];
n = stk_pop(lid);
wbytes += VTF3_WriteUpfrom(fcb, time*1.0e+10, (int) n->reg,
(unsigned int) lid, VTF3_SCLNONE);
genWriteCOUNTER(lid, time, metc, metv);
}
gint testPushPop(autounit_test_t *t) {
QueryNode queryNode;
stk_init(&stack);
queryNode.operator = QPP_OP_STAR;
stk_push(&stack,&queryNode);
stk_pop(&stack,&queryNode);
au_assert(t,"",queryNode.operator == QPP_OP_STAR);
return TRUE;
}
void *mem_get_object( mem_Object info )
{
objectInfo i = (objectInfo)info;
void *obj = stk_pop( i->stack );
_mem_magic_objects( i, __FUNCTION__ );
if (!obj) {
obj = obstack_alloc( i->obstack, i->size );
++i->total;
} else ++i->reused;
++i->used;
return obj;
}
void elg_readcb_EXIT(elg_ui4 lid, elg_d8 time, elg_ui1 metc, elg_ui8 metv[],
void* userdata) {
StackNode *n;
lid = locmap[lid];
n = stk_pop(lid);
if ( writeOMP && statetab[n->reg].act == act_omp
&& statetab[n->reg].type != ELG_FUNCTION ) {
wbytes += VTF3_WriteOpenmpleave(fcb, time*1.0e+10,
(unsigned int) lid, scl_of_state(n->reg));
} else {
wbytes += VTF3_WriteUpfrom(fcb, time*1.0e+10, (int) n->reg,
(unsigned int) lid, VTF3_SCLNONE);
}
genWriteCOUNTER(lid, time, metc, metv);
}
static void genWriteCOLLLEAVE(int w, elg_ui4 lid, elg_d8 time,
elg_ui4 rlid, elg_ui4 cid, elg_ui4 sent, elg_ui4 recvd) {
StackNode *n = stk_pop(lid);
if ( rlid != ELG_NO_ID ) rlid = locmap[rlid];
if ( w ) {
elg_d8 stime = (n->tim)*1.0e+10+1.0;
elg_d8 etime = time*1.0e+10-1.0;
if ( etime <= stime ) {
stime = (n->tim)*1.0e+10;
etime = time*1.0e+10;
}
wbytes += VTF3_WriteGlobalop(fcb, stime, n->reg,
(unsigned int) lid, (int) cid,
(unsigned int) rlid, (int) sent, (int) recvd,
etime-stime, VTF3_SCLNONE);
}
wbytes += VTF3_WriteUpfrom(fcb, time*1.0e+10, n->reg, (unsigned int) lid,
VTF3_SCLNONE);
}
int main()
{
int i;
/* Populate stack */
for (i = 0; i < 11; ++i)
stk_push(i);
if (stk_error())
puts("stack error");
printf("The last element pushed was %d\n",
stk_top());
/* Pop/print stack */
while (stk_size() > 0)
printf("%d ", stk_pop());
putchar('\n');
if (!stk_error())
puts("no stack error");
return 0;
}
/*
* Check if the given string is balanced
*/
int checkBalanced(StackPtr stack, char* n, int debug) {
//go through the string
int x = 0; //keep track of where the unbalanced symbol is
int unbalanced = 0;
int miss = 0;
int i;
for(i = 0; i < strlen(n) - 1; i++) {
//If we encounter an opening symbol
if(n[i] == '(' || n[i] == '{' || n[i] == '[' || n[i] == '<') {
if(debug) {
printf("Debug mode: Pushing to stack: %c\n", n[i]);
}
stk_push(stack, n[i], debug);
x++;
}
//if we encounter a closing symbol
if(n[i] == ')' || n[i] == '}' || n[i] == ']' || n[i] == '>'){
//if closing is encountered next, if correct closing bracket pop from stack
if(n[i] == ')') {
if(stk_top(stack) == '(') {
if(debug) {
printf("Debug mode: Popping from stack: %c\n", stk_top(stack));
}
stk_pop(stack);
} else {
miss = 1;
unbalanced = 1;
}
} else if(n[i] == '}') {
if(stk_top(stack) == '{') {
if(debug) {
printf("Debug mode: Popping from stack: %c\n", stk_top(stack));
}
stk_pop(stack);
} else {
miss = 2;
unbalanced = 1;
}
} else if(n[i] == ']') {
if(stk_top(stack) == '[') {
if(debug) {
printf("Debug mode: Popping from stack: %c\n", stk_top(stack));
}
stk_pop(stack);
} else {
miss = 3;
unbalanced = 1;
}
} else if(n[i] == '>') {
if(stk_top(stack) == '<') {
if(debug) {
printf("Debug mode: Popping from stack: %c\n", stk_top(stack));
}
stk_pop(stack);
} else {
miss = 4;
unbalanced = 1;
}
}
}
}
if(stk_is_empty(stack) && !unbalanced) {
printf("\n%s", n);
printf("Expression is Balanced!\n\n\n");
return 1;
} else {
printf("\n%s\n", n);
int i;
for(i = 0; i < x; i++) {
printf(" ");
}
printf("^");
if(miss == 1) {
printf(" missing (");
} else if(miss == 2) {
printf(" missing {");
} else if(miss == 3) {
printf(" missing [");
} else if(miss == 4) {
printf(" missing <");
}
printf("\n\n\n");
return 0;
}
}
/*
* Reads a single file (ie until get() returns EOF)
*/
static void read_file(paragraph *** ret, input * in, indexdata * idx)
{
token t;
paragraph par;
word wd, **whptr, **idximplicit;
tree234 *macros;
wchar_t utext[2], *wdtext;
int style, spcstyle;
int already;
int iswhite, seenwhite;
int type;
struct stack_item {
enum {
stack_nop = 0, /* do nothing (for error recovery) */
stack_ualt = 1, /* \u alternative */
stack_style = 2, /* \e, \c, \cw */
stack_idx = 4, /* \I, \i, \ii */
stack_hyper = 8, /* \W */
stack_quote = 16, /* \q */
} type;
word **whptr; /* to restore from \u alternatives */
word **idximplicit; /* to restore from \u alternatives */
} *sitem;
stack parsestk;
word *indexword=NULL, *uword=NULL, *iword=NULL;
word *idxwordlist;
rdstring indexstr;
int index_downcase=0, index_visible=0, indexing=0;
const rdstring nullrs = { 0, 0, NULL };
wchar_t uchr;
t.text = NULL;
macros = newtree234(macrocmp);
already = FALSE;
/*
* Loop on each paragraph.
*/
while (1)
{
int start_cmd = c__invalid;
par.words = NULL;
par.keyword = NULL;
whptr = &par.words;
/*
* Get a token.
*/
if (!already)
{
dtor(t), t = get_token(in);
}
already = FALSE;
if (t.type == tok_eof)
break;
/*
* Parse code paragraphs separately.
*/
if (t.type == tok_cmd && t.cmd == c_c && !isbrace(in))
{
par.type = para_Code;
par.fpos = t.pos;
while (1)
{
dtor(t), t = get_codepar_token(in);
wd.type = word_WeakCode;
wd.breaks = FALSE; /* shouldn't need this... */
wd.text = ustrdup(t.text);
wd.alt = NULL;
wd.fpos = t.pos;
addword(wd, &whptr);
dtor(t), t = get_token(in);
if (t.type == tok_white)
{
/*
* The newline after a code-paragraph line
*/
dtor(t), t = get_token(in);
}
if (t.type == tok_eop || t.type == tok_eof)
break;
else if (t.type != tok_cmd || t.cmd != c_c)
{
error(err_brokencodepara, &t.pos);
addpara(par, ret);
while (t.type != tok_eop) /* error recovery: */
dtor(t), t = get_token(in); /* eat rest of paragraph */
goto codeparabroken; /* ick, but such is life */
}
}
addpara(par, ret);
codeparabroken:
continue;
}
while (t.type == tok_cmd && macrolookup(macros, in, t.text, &t.pos))
{
dtor(t), t = get_token(in);
}
/*
* This token begins a paragraph. See if it's one of the
* special commands that define a paragraph type.
*
* (note that \# is special in a way, and \nocite takes no
* text)
*/
par.type = para_Normal;
if (t.type == tok_cmd)
{
int needkw=0;
int is_macro = FALSE;
par.fpos = t.pos;
switch (t.cmd)
{
default:
needkw = -1;
break;
case c__invalid:
error(err_badparatype, t.text, &t.pos);
needkw = 4;
break;
case c__comment:
if (isbrace(in))
break; /* `\#{': isn't a comment para */
do
{
dtor(t), t = get_token(in);
}
while (t.type != tok_eop && t.type != tok_eof);
continue; /* next paragraph */
/*
* `needkw' values:
*
* 1 -- exactly one keyword
* 2 -- at least one keyword
* 4 -- any number of keywords including zero
* 8 -- at least one keyword and then nothing else
* 16 -- nothing at all! no keywords, no body
* 32 -- no keywords at all
*/
case c_A:
needkw = 2;
par.type = para_Appendix;
break;
case c_B:
needkw = 2;
par.type = para_Biblio;
break;
case c_BR:
needkw = 1;
par.type = para_BR;
start_cmd = c_BR;
break;
case c_C:
needkw = 2;
par.type = para_Chapter;
break;
case c_H:
needkw = 2;
par.type = para_Heading;
par.aux = 0;
break;
case c_IM:
needkw = 2;
par.type = para_IM;
start_cmd = c_IM;
break;
case c_S:
needkw = 2;
par.type = para_Subsect;
par.aux = t.aux;
break;
case c_U:
needkw = 32;
par.type = para_UnnumberedChapter;
break;
/* For \b and \n the keyword is optional */
case c_b:
needkw = 4;
par.type = para_Bullet;
break;
case c_n:
needkw = 4;
par.type = para_NumberedList;
break;
case c_cfg:
needkw = 8;
par.type = para_Config;
start_cmd = c_cfg;
break;
case c_copyright:
needkw = 32;
par.type = para_Copyright;
break;
case c_define:
is_macro = TRUE;
needkw = 1;
break;
/* For \nocite the keyword is _everything_ */
case c_nocite:
needkw = 8;
par.type = para_NoCite;
break;
case c_preamble:
needkw = 32;
par.type = para_Preamble;
break;
case c_rule:
needkw = 16;
par.type = para_Rule;
break;
case c_title:
needkw = 32;
par.type = para_Title;
break;
case c_versionid:
needkw = 32;
par.type = para_VersionID;
break;
}
if (needkw > 0)
{
rdstring rs = { 0, 0, NULL };
int nkeys = 0;
filepos fp;
/* Get keywords. */
dtor(t), t = get_token(in);
fp = t.pos;
while (t.type == tok_lbrace)
{
/* This is a keyword. */
nkeys++;
/* FIXME: there will be bugs if anyone specifies an
* empty keyword (\foo{}), so trap this case. */
while (dtor(t), t = get_token(in),
t.type == tok_word ||
t.type == tok_white ||
(t.type == tok_cmd && t.cmd == c__nbsp) ||
(t.type == tok_cmd && t.cmd == c__escaped))
{
if (t.type == tok_white ||
(t.type == tok_cmd && t.cmd == c__nbsp))
rdadd(&rs, ' ');
else
rdadds(&rs, t.text);
}
if (t.type != tok_rbrace)
{
error(err_kwunclosed, &t.pos);
continue;
}
rdadd(&rs, 0); /* add string terminator */
dtor(t), t = get_token(in); /* eat right brace */
}
rdadd(&rs, 0); /* add string terminator */
/* See whether we have the right number of keywords. */
if ((needkw & 48) && nkeys > 0)
error(err_kwillegal, &fp);
if ((needkw & 11) && nkeys == 0)
error(err_kwexpected, &fp);
if ((needkw & 5) && nkeys > 1)
error(err_kwtoomany, &fp);
if (is_macro)
{
/*
* Macro definition. Get the rest of the line
* as a code-paragraph token, repeatedly until
* there's nothing more left of it. Separate
* with newlines.
*/
rdstring macrotext = { 0, 0, NULL };
while (1)
{
dtor(t), t = get_codepar_token(in);
if (macrotext.pos > 0)
rdadd(¯otext, L'\n');
rdadds(¯otext, t.text);
dtor(t), t = get_token(in);
if (t.type == tok_eop)
break;
}
macrodef(macros, rs.text, macrotext.text, fp);
continue; /* next paragraph */
}
par.keyword = rdtrim(&rs);
/* Move to EOP in case of needkw==8 or 16 (no body) */
if (needkw & 24)
{
/* We allow whitespace even when we expect no para body */
while (t.type == tok_white)
dtor(t), t = get_token(in);
if (t.type != tok_eop && t.type != tok_eof &&
(start_cmd == c__invalid ||
t.type != tok_cmd || t.cmd != start_cmd))
{
error(err_bodyillegal, &t.pos);
/* Error recovery: eat the rest of the paragraph */
while (t.type != tok_eop && t.type != tok_eof &&
(start_cmd == c__invalid ||
t.type != tok_cmd || t.cmd != start_cmd))
dtor(t), t = get_token(in);
}
if (t.type == tok_cmd)
already = TRUE; /* inhibit get_token at top of loop */
addpara(par, ret);
continue; /* next paragraph */
}
}
}
/*
* Now read the actual paragraph, word by word, adding to
* the paragraph list.
*
* Mid-paragraph commands:
*
* \K \k
* \c \cw
* \e
* \i \ii
* \I
* \u
* \W
* \date
* \\ \{ \}
*/
parsestk = stk_new();
style = word_Normal;
spcstyle = word_WhiteSpace;
indexing = FALSE;
seenwhite = TRUE;
while (t.type != tok_eop && t.type != tok_eof)
{
iswhite = FALSE;
already = FALSE;
/* Handle implicit paragraph breaks after \IM, \BR etc */
if (start_cmd != c__invalid &&
t.type == tok_cmd && t.cmd == start_cmd)
{
already = TRUE; /* inhibit get_token at top of loop */
break;
}
if (t.type == tok_cmd && t.cmd == c__escaped)
{
t.type = tok_word; /* nice and simple */
t.aux = 0; /* even if `\-' - nonbreaking! */
}
if (t.type == tok_cmd && t.cmd == c__nbsp)
{
t.type = tok_word; /* nice and simple */
sfree(t.text);
t.text = ustrdup(L" "); /* text is ` ' not `_' */
t.aux = 0; /* (nonbreaking) */
}
switch (t.type)
{
case tok_white:
if (whptr == &par.words)
break; /* strip whitespace at start of para */
wd.text = NULL;
wd.type = spcstyle;
wd.alt = NULL;
wd.aux = 0;
wd.fpos = t.pos;
wd.breaks = FALSE;
/*
* Inhibit use of whitespace if it's (probably the
* newline) before a repeat \IM / \BR type
* directive.
*/
if (start_cmd != c__invalid)
{
dtor(t), t = get_token(in);
already = TRUE;
if (t.type == tok_cmd && t.cmd == start_cmd)
break;
}
if (indexing)
rdadd(&indexstr, ' ');
if (!indexing || index_visible)
addword(wd, &whptr);
if (indexing)
addword(wd, &idximplicit);
iswhite = TRUE;
break;
case tok_word:
if (indexing)
rdadds(&indexstr, t.text);
wd.type = style;
wd.alt = NULL;
wd.aux = 0;
wd.fpos = t.pos;
wd.breaks = t.aux;
if (!indexing || index_visible)
{
wd.text = ustrdup(t.text);
addword(wd, &whptr);
}
if (indexing)
{
wd.text = ustrdup(t.text);
addword(wd, &idximplicit);
}
break;
case tok_lbrace:
error(err_unexbrace, &t.pos);
/* Error recovery: push nop */
sitem = mknew(struct stack_item);
sitem->type = stack_nop;
stk_push(parsestk, sitem);
break;
case tok_rbrace:
sitem = stk_pop(parsestk);
if (!sitem)
error(err_unexbrace, &t.pos);
else
{
if (sitem->type & stack_ualt)
{
whptr = sitem->whptr;
idximplicit = sitem->idximplicit;
}
if (sitem->type & stack_style)
{
style = word_Normal;
spcstyle = word_WhiteSpace;
}
if (sitem->type & stack_idx ) {
indexword->text = ustrdup(indexstr.text);
if (index_downcase)
ustrlow(indexword->text);
indexing = FALSE;
rdadd(&indexstr, L'\0');
index_merge(idx, FALSE, indexstr.text, idxwordlist);
sfree(indexstr.text);
}
if (sitem->type & stack_hyper)
{
wd.text = NULL;
wd.type = word_HyperEnd;
wd.alt = NULL;
wd.aux = 0;
wd.fpos = t.pos;
wd.breaks = FALSE;
if (!indexing || index_visible)
addword(wd, &whptr);
if (indexing)
addword(wd, &idximplicit);
}
if (sitem->type & stack_quote)
{
wd.text = NULL;
wd.type = toquotestyle(style);
wd.alt = NULL;
wd.aux = quote_Close;
wd.fpos = t.pos;
wd.breaks = FALSE;
if (!indexing || index_visible)
addword(wd, &whptr);
if (indexing)
{
rdadd(&indexstr, L'"');
addword(wd, &idximplicit);
}
}
}
sfree(sitem);
break;
case tok_cmd:
switch (t.cmd)
{
case c__comment:
/*
* In-paragraph comment: \#{ balanced braces }
*
* Anything goes here; even tok_eop. We should
* eat whitespace after the close brace _if_
* there was whitespace before the \#.
*/
dtor(t), t = get_token(in);
if (t.type != tok_lbrace)
{
error(err_explbr, &t.pos);
} else
{
int braces = 1;
while (braces > 0)
{
dtor(t), t = get_token(in);
if (t.type == tok_lbrace)
braces++;
else if (t.type == tok_rbrace)
braces--;
else if (t.type == tok_eof)
{
error(err_commenteof, &t.pos);
break;
}
}
}
if (seenwhite)
{
already = TRUE;
dtor(t), t = get_token(in);
if (t.type == tok_white)
{
iswhite = TRUE;
already = FALSE;
}
}
break;
case c_q:
dtor(t), t = get_token(in);
if (t.type != tok_lbrace)
{
error(err_explbr, &t.pos);
} else
{
wd.text = NULL;
wd.type = toquotestyle(style);
wd.alt = NULL;
wd.aux = quote_Open;
wd.fpos = t.pos;
wd.breaks = FALSE;
if (!indexing || index_visible)
addword(wd, &whptr);
if (indexing)
{
rdadd(&indexstr, L'"');
addword(wd, &idximplicit);
}
sitem = mknew(struct stack_item);
sitem->type = stack_quote;
stk_push(parsestk, sitem);
}
break;
case c_K:
case c_k:
case c_R:
case c_W:
case c_L:
case c_date:
/*
* Keyword, hyperlink, or \date. We expect a
* left brace, some text, and then a right
* brace. No nesting; no arguments.
*/
wd.fpos = t.pos;
wd.breaks = FALSE;
if (t.cmd == c_K)
wd.type = word_UpperXref;
else if (t.cmd == c_k)
wd.type = word_LowerXref;
else if (t.cmd == c_R)
wd.type = word_FreeTextXref;
else if (t.cmd == c_W)
wd.type = word_HyperLink;
else if (t.cmd == c_L)
wd.type = word_LocalHyperLink;
else
wd.type = word_Normal;
dtor(t), t = get_token(in);
if (t.type != tok_lbrace)
{
if (wd.type == word_Normal)
{
time_t thetime = time(NULL);
struct tm *broken = localtime(&thetime);
already = TRUE;
wdtext = ustrftime(NULL, broken);
wd.type = style;
} else
{
error(err_explbr, &t.pos);
wdtext = NULL;
}
} else
{
rdstring rs = { 0, 0, NULL };
while (dtor(t), t = get_token(in),
t.type == tok_word || t.type == tok_white)
{
if (t.type == tok_white)
rdadd(&rs, ' ');
else
rdadds(&rs, t.text);
}
if (wd.type == word_Normal)
{
time_t thetime = time(NULL);
struct tm *broken = localtime(&thetime);
wdtext = ustrftime(rs.text, broken);
wd.type = style;
} else
{
wdtext = ustrdup(rs.text);
}
sfree(rs.text);
if (t.type != tok_rbrace)
{
error(err_kwexprbr, &t.pos);
}
}
wd.alt = NULL;
wd.aux = 0;
if (!indexing || index_visible)
{
wd.text = ustrdup(wdtext);
addword(wd, &whptr);
}
if (indexing)
{
wd.text = ustrdup(wdtext);
addword(wd, &idximplicit);
}
sfree(wdtext);
if (wd.type == word_FreeTextXref || wd.type == word_HyperLink || wd.type == word_LocalHyperLink)
{
/*
* Hyperlinks are different: they then
* expect another left brace, to begin
* delimiting the text marked by the link.
*/
dtor(t), t = get_token(in);
/*
* Special cases: \W{}\c, \W{}\e, \W{}\cw
*/
sitem = mknew(struct stack_item);
sitem->type = stack_hyper;
if (t.type == tok_cmd &&
(t.cmd == c_e || t.cmd == c_c || t.cmd == c_cw))
{
if (style != word_Normal)
error(err_nestedstyles, &t.pos);
else
{
style = (t.cmd == c_c ? word_Code :
t.cmd == c_cw ? word_WeakCode : word_Emph);
spcstyle = tospacestyle(style);
sitem->type |= stack_style;
}
dtor(t), t = get_token(in);
}
if (t.type != tok_lbrace)
{
error(err_explbr, &t.pos);
sfree(sitem);
} else
{
stk_push(parsestk, sitem);
}
}
break;
case c_c:
case c_cw:
case c_e:
type = t.cmd;
if (style != word_Normal)
{
error(err_nestedstyles, &t.pos);
/* Error recovery: eat lbrace, push nop. */
dtor(t), t = get_token(in);
sitem = mknew(struct stack_item);
sitem->type = stack_nop;
stk_push(parsestk, sitem);
}
dtor(t), t = get_token(in);
if (t.type != tok_lbrace)
{
error(err_explbr, &t.pos);
} else
{
style = (type == c_c ? word_Code :
type == c_cw ? word_WeakCode : word_Emph);
spcstyle = tospacestyle(style);
sitem = mknew(struct stack_item);
sitem->type = stack_style;
stk_push(parsestk, sitem);
}
break;
case c_i:
case c_ii:
case c_I:
type = t.cmd;
if (indexing)
{
error(err_nestedindex, &t.pos);
/* Error recovery: eat lbrace, push nop. */
dtor(t), t = get_token(in);
sitem = mknew(struct stack_item);
sitem->type = stack_nop;
stk_push(parsestk, sitem);
}
sitem = mknew(struct stack_item);
sitem->type = stack_idx;
dtor(t), t = get_token(in);
/*
* Special cases: \i\c, \i\e, \i\cw
*/
wd.fpos = t.pos;
if (t.type == tok_cmd &&
(t.cmd == c_e || t.cmd == c_c || t.cmd == c_cw))
{
if (style != word_Normal)
error(err_nestedstyles, &t.pos);
else
{
style = (t.cmd == c_c ? word_Code :
t.cmd == c_cw ? word_WeakCode : word_Emph);
spcstyle = tospacestyle(style);
sitem->type |= stack_style;
}
dtor(t), t = get_token(in);
}
if (t.type != tok_lbrace)
{
sfree(sitem);
error(err_explbr, &t.pos);
} else
{
/* Add an index-reference word with no text as yet */
wd.type = word_IndexRef;
wd.text = NULL;
wd.alt = NULL;
wd.aux = 0;
wd.breaks = FALSE;
indexword = addword(wd, &whptr);
/* Set up a rdstring to read the index text */
indexstr = nullrs;
/* Flags so that we do the Right Things with text */
index_visible = (type != c_I);
index_downcase = (type == c_ii);
indexing = TRUE;
idxwordlist = NULL;
idximplicit = &idxwordlist;
/* Stack item to close the indexing on exit */
stk_push(parsestk, sitem);
}
break;
case c_u:
uchr = t.aux;
utext[0] = uchr;
utext[1] = 0;
wd.type = style;
wd.breaks = FALSE;
wd.alt = NULL;
wd.aux = 0;
wd.fpos = t.pos;
if (!indexing || index_visible)
{
wd.text = ustrdup(utext);
uword = addword(wd, &whptr);
} else
uword = NULL;
if (indexing)
{
wd.text = ustrdup(utext);
iword = addword(wd, &idximplicit);
} else
iword = NULL;
dtor(t), t = get_token(in);
if (t.type == tok_lbrace)
{
/*
* \u with a left brace. Until the brace
* closes, all further words go on a
* sidetrack from the main thread of the
* paragraph.
*/
sitem = mknew(struct stack_item);
sitem->type = stack_ualt;
sitem->whptr = whptr;
sitem->idximplicit = idximplicit;
stk_push(parsestk, sitem);
whptr = uword ? &uword->alt : NULL;
idximplicit = iword ? &iword->alt : NULL;
} else
{
if (indexing)
rdadd(&indexstr, uchr);
already = TRUE;
}
break;
default:
if (!macrolookup(macros, in, t.text, &t.pos))
error(err_badmidcmd, t.text, &t.pos);
break;
}
void impl( )
{
stk_t * k = stk_new();
char cur;
int lhs;
int rhs;
int val;
int total = 0;
while( (cur = fgetc(stdin)) != EOF )
{
if(isdigit(cur))
{
int digits[MAXDIGITS];
int n_digits = 0;
digits[ n_digits++ ] = cur - '0';
while( (cur = fgetc(stdin)) != EOF && isdigit(cur) && n_digits < MAXDIGITS)
digits[ n_digits++ ] = cur - '0';
int val = 0;
for(int i = 0, j = n_digits - 1; i < n_digits; i ++, j-- )
val += digits[i] * pow(10, j);
stk_push(k, val);
}
switch(cur)
{
// handle operators
case '%':
case '+':
case '-':
case '*':
case '/':
//printf("got op, %c\n",cur);
if(! stk_is_empty(k) )
if( (lhs = stk_pop(k)) == -1 )
{
printf("Bad lhs pop\n");
return;
}
if(! stk_is_empty(k) )
{
if( (rhs = stk_pop(k)) == -1 )
{
printf("Bad rhs pop\n");
return;
}
fprintf(stdout, "lhs %d, rhs %d, op %c\n",lhs,rhs,cur);
stk_push(k, calc_op(cur, lhs, rhs));
}
else
{
stk_push(k,lhs);
stk_push(k,cur);
}
break;
// clear stack with _ underscore
case '_':
calc_clear(k);
break;
case '.':
calc_print_top(k,stdout);
break;
case '>':
calc_swap_top(k);
break;
}
}
stk_dump(k,stdout);
stk_free(k);
}
void elg_readcb_EXIT(elg_ui4 lid, elg_d8 time, elg_ui1 metc, elg_ui8 metv[], void* userdata) {
MYDATA* md = (MYDATA*) userdata;
StackNode *n;
int i;
struct {
int16_t length;
char *string;
} val;
lid = locmap[lid];
n = stk_pop(lid);
#ifdef DEBUG
printf("Exit on %d, %d, %s\n",lid, n->reg, statetab[n->reg].name);
#endif
if(primitives == NULL) {
primitives = (PRIMITIVES_List*) malloc(sizeof(struct _primitives_list));
last_primitive = primitives;
primitives->size = 0;
} else {
last_primitive->next = (PRIMITIVES_List*) malloc(sizeof(struct _primitives_list));
last_primitive = last_primitive->next;
}
/* New Event */
primitives->size++;
last_primitive->next = NULL;
last_primitive->prim = (DRAW_Primitive *) malloc(sizeof(DRAW_Primitive));
last_primitive->prim->starttime = n->tim;
last_primitive->prim->endtime = time;
if (!strcmp(stringtab[statetab[n->reg].act],"EPIK")) {
last_primitive->prim->type_idx = ST_EPIK;
} else if (!strcmp(stringtab[statetab[n->reg].act],"USR")) {
last_primitive->prim->type_idx = ST_USER;
} else if (!strcmp(stringtab[statetab[n->reg].act],"OMP")) {
if (strstr(statetab[n->reg].name,"sblock") != NULL ||
(strstr(statetab[n->reg].name,"section") != NULL &&
strstr(statetab[n->reg].name,"sections") == NULL)) {
last_primitive->prim->type_idx = ST_USER;
} else {
last_primitive->prim->type_idx = ST_OMP;
}
} else if (!strcmp(stringtab[statetab[n->reg].act],"MPI")) {
for(i=0; i < MPI_FUNCTIONS; i++) {
if(!strcmp(statetab[n->reg].name,slog2_mpi_tab[i].name)) {
last_primitive->prim->type_idx = slog2_mpi_tab[i].state;
break;
}
}
} else {
fprintf(stderr, "!!!Error1 - Function: %s in Group %s not implemented!!!!\n", statetab[n->reg].name, stringtab[statetab[n->reg].act]);
exit(1);
}
last_primitive->prim->num_tcoords = 2;
last_primitive->prim->tcoords = (double*) malloc(2*sizeof(double));
last_primitive->prim->tcoords[0] = n->tim;
last_primitive->prim->tcoords[1] = time;
last_primitive->prim->num_ycoords = 2;
last_primitive->prim->ycoords = (int*) malloc(2*sizeof(int));
last_primitive->prim->ycoords[0] = lid;
last_primitive->prim->ycoords[1] = lid;
last_primitive->prim->num_info = sizeof(int16_t)+strlen(statetab[n->reg].name)*sizeof(char);
last_primitive->prim->info = (char*) malloc(last_primitive->prim->num_info*sizeof(char));
val.string = (char *) malloc(strlen(statetab[n->reg].name)*sizeof(char));
strcpy(val.string, statetab[n->reg].name);
val.length = strlen(statetab[n->reg].name);
if(ELG_BYTE_ORDER == ELG_LITTLE_ENDIAN) {
elg_swap(&val.length, sizeof(int16_t));
}
memcpy(last_primitive->prim->info, &val.length, sizeof(int16_t));
memcpy(last_primitive->prim->info+sizeof(int16_t), val.string, strlen(statetab[n->reg].name)*sizeof(char));
}
void stk_dump(stk_t * s,FILE * out)
{
fprintf(out,"stk_dump:\n" );
while( ! stk_is_empty(s) )
fprintf(out,"%d\n", stk_pop(s) );
}
void elg_readcb_MPI_COLLEXIT(elg_ui4 lid, elg_d8 time, elg_ui1 metc, elg_ui8 metv[], elg_ui4 rlid, elg_ui4 cid, elg_ui4 sent, elg_ui4 recvd, void* userdata) {
MYDATA* md = (MYDATA*) userdata;
StackNode *n;
int i;
struct {
int16_t length;
char *string;
} val;
lid = locmap[lid];
if ( rlid != ELG_NO_ID ) rlid = locmap[rlid];
n = stk_pop(lid);
if(primitives == NULL) {
primitives = (PRIMITIVES_List*) malloc(sizeof(struct _primitives_list));
last_primitive = primitives;
primitives->size = 0;
} else {
last_primitive->next = (PRIMITIVES_List*) malloc(sizeof(struct _primitives_list));
last_primitive = last_primitive->next;
}
/* New Event */
primitives->size++;
last_primitive->next = NULL;
last_primitive->prim = (DRAW_Primitive *) malloc(sizeof(DRAW_Primitive));
last_primitive->prim->starttime = n->tim;
last_primitive->prim->endtime = time;
//last_primitive->prim->type_idx = n->reg;
if(!strcmp(stringtab[statetab[n->reg].act],"MPI")) {
for(i=0; i < MPI_FUNCTIONS; i++) {
if(!strcmp(statetab[n->reg].name,slog2_mpi_tab[i].name)) {
last_primitive->prim->type_idx = slog2_mpi_tab[i].state;//n->reg;
break;
}
}
} else {
fprintf(stderr, "!!!Error - Function: %s not implemented!!!!", statetab[n->reg].name);
exit(1);
}
last_primitive->prim->num_tcoords = 2;
last_primitive->prim->tcoords = (double*) malloc(2*sizeof(double));
last_primitive->prim->tcoords[0] = n->tim;
last_primitive->prim->tcoords[1] = time;
last_primitive->prim->num_ycoords = 2;
last_primitive->prim->ycoords = (int*) malloc(2*sizeof(int));
last_primitive->prim->ycoords[0] = lid;
last_primitive->prim->ycoords[1] = lid;
last_primitive->prim->num_info = sizeof(int16_t)+strlen(statetab[n->reg].name)*sizeof(char);
last_primitive->prim->info = (char*) malloc(last_primitive->prim->num_info*sizeof(char));
val.string = (char *) malloc(strlen(statetab[n->reg].name)*sizeof(char));
strcpy(val.string, statetab[n->reg].name);
val.length = strlen(statetab[n->reg].name);
if(ELG_BYTE_ORDER == ELG_LITTLE_ENDIAN) {
elg_swap(&val.length, sizeof(int16_t));
}
memcpy(last_primitive->prim->info, &val.length, sizeof(int16_t));
memcpy(last_primitive->prim->info+sizeof(int16_t), val.string, strlen(statetab[n->reg].name)*sizeof(char));
}
void elg_readcb_OMP_COLLEXIT(elg_ui4 lid, elg_d8 time,
elg_ui1 metc, elg_ui8 metv[], void* userdata) {
MYDATA* md = (MYDATA*) userdata;
StackNode *n;
int i;
struct {
int16_t length;
char *string;
} val;
lid = locmap[lid];
n = stk_pop(lid);
#ifdef DEBUG
printf("OMP CollExit on %d, %d, %s\n",lid, n->reg, statetab[n->reg].name);
#endif
if(primitives == NULL) {
primitives = (PRIMITIVES_List*) malloc(sizeof(struct _primitives_list));
last_primitive = primitives;
primitives->size = 0;
} else {
last_primitive->next = (PRIMITIVES_List*) malloc(sizeof(struct _primitives_list));
last_primitive = last_primitive->next;
}
/* New Event */
primitives->size++;
last_primitive->next = NULL;
last_primitive->prim = (DRAW_Primitive *) malloc(sizeof(DRAW_Primitive));
last_primitive->prim->starttime = n->tim;
last_primitive->prim->endtime = time;
if( !strncmp(statetab[n->reg].name,"!$omp barrier",13) ||
! strncmp(statetab[n->reg].name,"!$omp ibarrier",14) ) {
last_primitive->prim->type_idx = ST_OMPCOLL;
} else if (!strncmp(statetab[n->reg].name,"!$omp parallel",14)) {
last_primitive->prim->type_idx = ST_USER;
} else {
last_primitive->prim->type_idx = ST_OMP;
}
last_primitive->prim->num_tcoords = 2;
last_primitive->prim->tcoords = (double*) malloc(2*sizeof(double));
last_primitive->prim->tcoords[0] = n->tim;
last_primitive->prim->tcoords[1] = time;
last_primitive->prim->num_ycoords = 2;
last_primitive->prim->ycoords = (int*) malloc(2*sizeof(int));
last_primitive->prim->ycoords[0] = lid;
last_primitive->prim->ycoords[1] = lid;
last_primitive->prim->num_info = sizeof(int16_t)+strlen(statetab[n->reg].name)*sizeof(char);
last_primitive->prim->info = (char*) malloc(last_primitive->prim->num_info*sizeof(char));
val.string = (char *) malloc(strlen(statetab[n->reg].name)*sizeof(char));
strcpy(val.string, statetab[n->reg].name);
val.length = strlen(statetab[n->reg].name);
if(ELG_BYTE_ORDER == ELG_LITTLE_ENDIAN) {
elg_swap(&val.length, sizeof(int16_t));
}
memcpy(last_primitive->prim->info, &val.length, sizeof(int16_t));
memcpy(last_primitive->prim->info+sizeof(int16_t), val.string, strlen(statetab[n->reg].name)*sizeof(char));
// if( !strncmp(statetab[n->reg].name,"!$omp barrier",13) ||
// ! strncmp(statetab[n->reg].name,"!$omp ibarrier",14) ) {
// printf("OMP Collective!\n");
// }
}
void elg_readcb_EXIT_TRACING(elg_ui4 lid, elg_d8 time,
elg_ui1 metc, elg_ui8 metv[], void* userdata) {
MYDATA* md = (MYDATA*) userdata;
StackNode *n, *p;
int i;
struct {
int16_t length;
char *string;
} val;
lid = locmap[lid];
//if ( rlid != ELG_NO_ID ) rlid = locmap[rlid];
n = stk_pop(lid);
if(primitives == NULL) {
primitives = (PRIMITIVES_List*) malloc(sizeof(struct _primitives_list));
last_primitive = primitives;
primitives->size = 0;
} else {
last_primitive->next = (PRIMITIVES_List*) malloc(sizeof(struct _primitives_list));
last_primitive = last_primitive->next;
}
/* New Event */
primitives->size++;
last_primitive->next = NULL;
last_primitive->prim = (DRAW_Primitive *) malloc(sizeof(DRAW_Primitive));
last_primitive->prim->starttime = n->tim;
last_primitive->prim->endtime = time;
last_primitive->prim->type_idx = ST_EPIK;
last_primitive->prim->num_tcoords = 2;
last_primitive->prim->tcoords = (double*) malloc(2*sizeof(double));
last_primitive->prim->tcoords[0] = n->tim;
last_primitive->prim->tcoords[1] = time;
last_primitive->prim->num_ycoords = 2;
last_primitive->prim->ycoords = (int*) malloc(2*sizeof(int));
last_primitive->prim->ycoords[0] = lid;
last_primitive->prim->ycoords[1] = lid;
p = stk_top(lid);
if(!strcmp(statetab[p->reg].name,"MPI_Init")) {
last_primitive->prim->num_info = sizeof(int16_t)+21*sizeof(char);
last_primitive->prim->info = (char*) malloc(21*sizeof(char));
strcpy(last_primitive->prim->info, "Epik - Initialization");
last_primitive->prim->info = (char*) malloc(last_primitive->prim->num_info*sizeof(char));
val.string = (char *) malloc(21*sizeof(char));
strcpy(val.string, "Epik - Initialization");
val.length = 21;
if(ELG_BYTE_ORDER == ELG_LITTLE_ENDIAN) {
elg_swap(&val.length, sizeof(int16_t));
}
memcpy(last_primitive->prim->info, &val.length, sizeof(int16_t));
memcpy(last_primitive->prim->info+sizeof(int16_t), val.string, 21*sizeof(char));
} else if(!strcmp(statetab[p->reg].name,"MPI_Finalize")){
last_primitive->prim->num_info = sizeof(int16_t)+19*sizeof(char);
last_primitive->prim->info = (char*) malloc(19*sizeof(char));
strcpy(last_primitive->prim->info, "Epik - Finalization");
last_primitive->prim->info = (char*) malloc(last_primitive->prim->num_info*sizeof(char));
val.string = (char *) malloc(19*sizeof(char));
strcpy(val.string, "Epik - Finalization");
val.length = 19;
if(ELG_BYTE_ORDER == ELG_LITTLE_ENDIAN) {
elg_swap(&val.length, sizeof(int16_t));
}
memcpy(last_primitive->prim->info, &val.length, sizeof(int16_t));
memcpy(last_primitive->prim->info+sizeof(int16_t), val.string, 19*sizeof(char));
} else {
last_primitive->prim->num_info = sizeof(int16_t)+12*sizeof(char);
last_primitive->prim->info = (char*) malloc(12*sizeof(char));
strcpy(last_primitive->prim->info, "Epik - Flush");
last_primitive->prim->info = (char*) malloc(last_primitive->prim->num_info*sizeof(char));
val.string = (char *) malloc(12*sizeof(char));
strcpy(val.string, "Epik - Flush");
val.length = 12;
if(ELG_BYTE_ORDER == ELG_LITTLE_ENDIAN) {
elg_swap(&val.length, sizeof(int16_t));
}
memcpy(last_primitive->prim->info, &val.length, sizeof(int16_t));
memcpy(last_primitive->prim->info+sizeof(int16_t), val.string, 12*sizeof(char));
}
}
