gint testMove2(autounit_test_t *t) {
Stack stkFrom,stkTo;
QueryNode tmp;
stk_init(&stkFrom);
stk_init(&stkTo);
tmp.operator = QPP_OP_OR;
stk_push(&stkFrom,&tmp);
tmp.operator = QPP_OP_AND;
stk_push(&stkFrom,&tmp);
tmp.operator = QPP_OP_NEAR;
stk_push(&stkFrom,&tmp);
stk_moveTillParen(&stkFrom,&stkTo);
au_assert(t,"",stkTo.queryNodes[0].operator == QPP_OP_NEAR);
au_assert(t,"",stkTo.queryNodes[1].operator == QPP_OP_AND);
au_assert(t,"",stkTo.queryNodes[2].operator == QPP_OP_OR);
au_assert(t,"",stkTo.index == 3);
return TRUE;
}
void elg_readcb_ENTER_CS(elg_ui4 lid, elg_d8 time, elg_ui4 csid,
elg_ui1 metc, elg_ui8 metv[], void* userdata) {
lid = locmap[lid];
if ( need_usr && stk_top(lid)->reg == ELG_NO_ID ) {
stk_push(lid, state_user, time);
wbytes += VTF3_WriteDownto(fcb, time*1.0e+10, state_user,
(unsigned int) lid, VTF3_SCLNONE);
}
stk_push(lid, csitetab[csid].erid, time);
wbytes += VTF3_WriteDownto(fcb, time*1.0e+10, (int) csitetab[csid].erid,
(unsigned int) lid, scl_of_csite(csid));
genWriteCOUNTER(lid, time, metc, metv);
}
void elg_readcb_OMP_FORK(elg_ui4 lid, elg_d8 time, void* userdata) {
#ifdef DEBUG
printf("OMP fork on %d!\n",lid);
#endif
lid = locmap[lid];
stk_push(lid, lid, time);
}
void elg_readcb_ENTER_CS(elg_ui4 lid, elg_d8 time, elg_ui4 csid,
elg_ui1 metc, elg_ui8 metv[], void* userdata) {
MYDATA* md = (MYDATA*) userdata;
lid = locmap[lid];
stk_push(lid, csitetab[csid].erid, time);
}
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;
}
static int pushStarHackedOperand(void* word_db, StateObj *pStObj,QueryNode *pQuNode, char *original_word) {
int ret=0;
/* LWord retWord={"",0,-1,0};*/
/* word_t word={"",{0,0,0}};*/
makeUpperLetter(pQuNode);
pQuNode->word_st.string[MAX_WORD_LEN-1]='\0';
pQuNode->type = OPERAND;
if (pStObj->searchField == -1) {
pQuNode->field = mDefaultSearchField;
}
else {
pQuNode->field = (1L << pStObj->searchField);
}
if (pStObj->searchField == -1 && pStObj->posWithinPhrase == TRUE) {
pQuNode->field = mDefaultPhraseField;
}
else if (pStObj->searchField == -1 && pStObj->truncated == 1) {
// pQuNode->field = 0xffffffff;
pStObj->truncated = 0;
}
if (pStObj->virtualfield != 0) {
pQuNode->field = pStObj->virtualfield;
}
pQuNode->opParam = pStObj->searchField; /* obsolete ? */
pQuNode->weight = 1;
ret = sb_run_get_word(word_db, &(pQuNode->word_st));
if (ret == WORD_NOT_REGISTERED) {
INFO("user entered unknown word: [%s]",pQuNode->word_st.string);
INFO("ret wordid is [%u]",pQuNode->word_st.id);
pQuNode->word_st.id = 0;
}
else if (ret < 0) {
error("can't get wordid. error[%d]",ret);
pQuNode->word_st.string[0]= '\0';
pQuNode->word_st.id= 0;
}else{
/* pQuNode->word_st = retWord;*/
DEBUG("su_run_get_word ret:(%d) , word[%s], wordid:(%d)",
ret, pQuNode->word_st.string, pQuNode->word_st.id);
}
if ( pStObj->natural_search == 1 &&
ret == WORD_NOT_REGISTERED) {
pQuNode->opParam = -10;
}
strncpy(pQuNode->word_st.string, original_word, MAX_WORD_LEN-1);
pQuNode->word_st.string[MAX_WORD_LEN-1]='\0';
return stk_push(&pStObj->postfixStack,pQuNode);
}
static int pushZeroWordid(StateObj *pStObj) {
if (pStObj->nextTurn == TURN_OPERAND &&
pStObj->posWithinPhrase == FALSE) {
pStObj->nextTurn = TURN_BINARY_OPERATOR;
return stk_push(&(pStObj->postfixStack),&m_zeroWordidNode);
}
return SUCCESS;
}
void mem_free_object( mem_Object info, void *obj )
{
objectInfo i = (objectInfo)info;
_mem_magic_objects( i, __FUNCTION__ );
stk_push( i->stack, obj );
--i->used;
}
static int pushFakeOperand(StateObj *pStObj) {
if (pStObj->nextTurn == TURN_OPERAND &&
pStObj->posWithinPhrase == FALSE) {
pStObj->nextTurn = TURN_BINARY_OPERATOR;
DEBUG("pushing fake operand to stack");
return stk_push(&(pStObj->postfixStack),&m_fakeQueryNode);
}
return SUCCESS;
}
static int pushPhrase(StateObj *pStObj){
QueryNode quNode;
quNode.type = OPERATOR;
quNode.operator = QPP_OP_PHRASE;
quNode.opParam = 1;
quNode.num_of_operands = pStObj->numPhraseOperand;
return stk_push(&(pStObj->postfixStack),&quNode);
}
void elg_readcb_ENTER(elg_ui4 lid, elg_d8 time, elg_ui4 rid,
elg_ui1 metc, elg_ui8 metv[], void* userdata) {
MYDATA* md = (MYDATA*) userdata;
lid = locmap[lid];
stk_push(lid, rid, time);
#ifdef DEBUG
printf("Enter on rank %d, Region: %d, ID: %d, Group: %d, Groupname: %s, Name: %s\n",lid, rid, statetab[rid].id, statetab[rid].act, stringtab[statetab[rid].act], statetab[rid].name);
#endif
}
static int pushNumeric(StateObj *pStObj,QueryNode *pQuNode) {
pQuNode->operator = QPP_OP_NUMERIC;
pQuNode->opParam = pStObj->searchField;
pStObj->searchField = -1;
stk_removeLast(&(pStObj->operatorStack));
pStObj->nextTurn = TURN_BINARY_OPERATOR;
return stk_push(&(pStObj->postfixStack),pQuNode);
}
void elg_readcb_ENTER(elg_ui4 lid, elg_d8 time, elg_ui4 rid,
elg_ui1 metc, elg_ui8 metv[], void* userdata) {
lid = locmap[lid];
if ( need_usr && stk_top(lid)->reg == ELG_NO_ID ) {
stk_push(lid, state_user, time);
wbytes += VTF3_WriteDownto(fcb, time*1.0e+10, state_user,
(unsigned int) lid, VTF3_SCLNONE);
}
stk_push(lid, rid, time);
if ( writeOMP && statetab[rid].act == act_omp
&& statetab[rid].type != ELG_FUNCTION ) {
wbytes += VTF3_WriteOpenmpenter(fcb, time*1.0e+10, (unsigned int) lid,
(unsigned int) statetab[rid].type,
(unsigned int) rid,
scl_of_state(rid));
} else {
wbytes += VTF3_WriteDownto(fcb, time*1.0e+10, (int) rid,
(unsigned int) lid, scl_of_state(rid));
}
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;
}
static int pushGenericOperator(StateObj *pStObj,QueryNode *pQuNode){
QueryNode peekNode;
int nRet = SUCCESS;
while (1) {
nRet = stk_peek(&(pStObj->operatorStack),&peekNode);
if (nRet == STACK_UNDERFLOW){
nRet = stk_push(&(pStObj->operatorStack),pQuNode);
return nRet;
}
else if (mPrecedence[(uint16_t)peekNode.operator] >=
mPrecedence[(uint16_t)pQuNode->operator]) {
if (peekNode.operator == QPP_OP_FIELD) {
stk_removeLast(&(pStObj->operatorStack));
pStObj->searchField = -1;
pStObj->virtualfield = 0;
}
else if (peekNode.operator == QPP_OP_VIRTUAL_FIELD) {
stk_removeLast(&(pStObj->operatorStack));
pStObj->searchField = -1;
pStObj->virtualfield = 0;
}
else
nRet = stk_move(&(pStObj->operatorStack),&(pStObj->postfixStack));
}
else if (mPrecedence[(uint16_t)peekNode.operator] <
mPrecedence[(uint16_t)pQuNode->operator]) {
nRet = stk_push(&(pStObj->operatorStack),pQuNode);
return nRet;
}
if (nRet < 0)
break;
}
return nRet;
}
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;
}
}
static int pushExtendedOperand(void* word_db, StateObj *pStObj,QueryNode *pQuNode) {
QueryNode qnode;
int nRet = 0;
int nMorpheme = 0;
int i = 0;
index_word_extractor_t *extractor=NULL;
index_word_t indexwords[ENOUGH_INDEXWORD_NUM];
int morp_id=0, indexwordnum=0;
nRet = pushDefaultOperator(pStObj);
DEBUG(" nRet of pushDefaultOperator is [%d] ",nRet);
if ( nRet < 0 ) return nRet;
if (is_both_end_bigram_truncation(pQuNode->original_word) == TRUE) {
int len = strlen(pQuNode->original_word);
pQuNode->original_word[len-1] = '\0';
/* XXX: moving including NULL */
memmove(pQuNode->original_word, pQuNode->original_word+1, len-1);
return pushBothEndBigram(word_db, pStObj, pQuNode);
}
else if (is_left_end_bigram_truncation(pQuNode->original_word) == TRUE) {
int len = strlen(pQuNode->original_word);
/* XXX: moving including NULL */
memmove(pQuNode->original_word, pQuNode->original_word+1, len);
return pushLeftEndBigram(word_db, pStObj, pQuNode);
}
else if (is_right_end_bigram_truncation(pQuNode->original_word) == TRUE) {
int len = strlen(pQuNode->original_word);
pQuNode->original_word[len-1] = '\0';
DEBUG("original_word for word> : %s", pQuNode->original_word);
return pushRightEndBigram(word_db, pStObj, pQuNode);
}
morp_id = mQppMorpAnalyzerId[pStObj->searchField];
debug("morp_id[%d], mMorpIdForPhrase[%d], virtualfield_morpid[%d]",
morp_id, mMorpIdForPhrase, pStObj->virtualfield_morpid);
if (pStObj->posWithinPhrase == TRUE) {
/* 구문검색시 무조건 바이그램을 쓰지 않도록 수정 */
morp_id = mMorpIdForPhrase;
}
if (pStObj->virtualfield != 0) {
morp_id = pStObj->virtualfield_morpid;
}
extractor = sb_run_new_index_word_extractor(morp_id);
if (extractor == NULL || extractor == (index_word_extractor_t*)MINUS_DECLINE) {
error("cannot create index_word_extractor: %p", extractor);
return FAIL;
}
//sb_run_index_word_extractor_set_text(extractor, pQuNode->word_st.string);
info("original_word:%s", pQuNode->original_word);
strncpy(pQuNode->word_st.string, pQuNode->original_word, MAX_WORD_LEN-1);
pQuNode->word_st.string[MAX_WORD_LEN-1] = '\0';
cut_string(pQuNode->word_st.string, MAX_WORD_LEN-2);
sb_run_index_word_extractor_set_text(extractor, pQuNode->original_word);
//XXX: get_index_words should be called in a loop
// (more than MAX_QPP_INDEXED_WORDS indexwords can be returned)
nRet = sb_run_get_index_words(extractor, indexwords, ENOUGH_INDEXWORD_NUM);
if (nRet < 0) {
error("error while getting index_words. nRet[%d]", nRet);
sb_run_delete_index_word_extractor(extractor);
return FAIL;
}
indexwordnum = nRet;
if (indexwordnum > MAX_QPP_INDEXED_WORDS) {
indexwordnum = reduce_index_words(indexwords, indexwordnum);
}
nMorpheme = indexwordnum;
sb_run_delete_index_word_extractor(extractor);
// daum_koma를 사용하는 경우 특수처리
// 이놈은 boolean query를 리턴한다
/*
if ( morp_id == 16 ) {
char buf[STRING_SIZE];
struct daum_tree_node* tree = parse_daum_query(indexwords, nMorpheme);
if ( tree == NULL ) {
error("failed parsing daum koma query: %s", pQuNode->original_word);
return FAIL;
}
info("original query: [%s]", pQuNode->original_word);
info("parsed daum query: [%s]", print_daum_tree(tree, buf, sizeof(buf)));
if ( push_daum_tree(word_db, pStObj, tree) != SUCCESS ) {
error("push_daum_tree failed");
destroy_daum_tree(tree);
return FAIL;
}
// 단어가 등장하면 최소한 { 가 } 와 같이 3개가 나온다
if ( nMorpheme >= 3 && pStObj->posWithinPhrase == TRUE ) {
pStObj->numPhraseOperand++;
}
destroy_daum_tree(tree);
pStObj->nextTurn = TURN_BINARY_OPERATOR;
return SUCCESS;
}
else*/
if (nMorpheme > 0) {
for (i=0; i<nMorpheme; i++) {
strncpy(qnode.word_st.string, indexwords[i].word, MAX_WORD_LEN-1);
qnode.word_st.string[MAX_WORD_LEN-1] = '\0';
cut_string(qnode.word_st.string, MAX_WORD_LEN-2);
INFO("qnode[%d] word:%s", i, qnode.word_st.string);
nRet = pushOperand(word_db, pStObj, &qnode);
if (nRet < 0) {
error("failed to push operand for word[%s]",
qnode.word_st.string);
return FAIL;
}
}
if (pStObj->posWithinPhrase == TRUE) {
pStObj->numPhraseOperand++;
}
/* 하나의 토큰에서 두개이상의 색인어가 추출되는 경우 within 연산으로 처리 */
if (nMorpheme > 1) {
qnode.type = OPERATOR;
qnode.operator = QPP_OP_WITHIN;
qnode.opParam = 0; /* within 0 */
qnode.num_of_operands = nMorpheme;
nRet = stk_push(&(pStObj->postfixStack),&qnode);
if (nRet < 0)
return nRet;
}
} else {
/* 색인어가 없는 경우 바로 리턴한다. */
return SUCCESS;
}
/*
* 형태소분석 : 10 <= morp_id < 20
* 바이그램 : 20 <= morp_id < 30
*/
/* 형태소분석 결과의 버그를 피해가는 코드는 사용하지 않는다.
* 2007-09-18 김정겸 */
#if 0
/*
if (nMorpheme == 0 && (morp_id >= 10 && morp_id < 20)) {
// 형태소 분석 결과가 없으면 원래 단어로 검색
nRet = pushOperand(pStObj, pQuNode);
if (nRet < 0) {
error("error while pushing original wordp[%s] into stack",
pQuNode->word_st.string);
return nRet;
}
} else
*/
if (nMorpheme == 1 &&
(morp_id >= 10 && morp_id < 20)) {
/* 형태소 분석 결과 단어와 입력단어가 다르면 입력단어를 OR 검색으로 추가 */
if ( strncmp(pQuNode->original_word, indexwords[0].word, MAX_WORD_LEN) != 0) {
// or with original word
nRet = pushOperand(word_db, pStObj, pQuNode);
if (nRet < 0) {
error("error while pushing original wordp[%s] into stack",
pQuNode->word_st.string);
return nRet;
}
qnode.type = OPERATOR;
qnode.operator = QPP_OP_OR;
qnode.num_of_operands = 2;
nRet = stk_push(&(pStObj->postfixStack), &qnode);
if (nRet < 0) {
error("error while pushing original word into stack");
return nRet;
}
}
}
else if (nMorpheme >= 2 &&
(morp_id >= 10 && morp_id < 20)) {
/* 형태소 분석 결과 단어와 입력단어가 다르면 입력단어를 OR 검색으로 추가 */
// or with original word
nRet = pushOperand(word_db, pStObj, pQuNode);
if (nRet < 0) {
error("error while pushing original word[%s] into stack",
pQuNode->word_st.string);
return nRet;
}
qnode.type = OPERATOR;
qnode.operator = QPP_OP_OR;
qnode.num_of_operands = 2;
nRet = stk_push(&(pStObj->postfixStack), &qnode);
if (nRet < 0) {
error("error while pushing original word into stack");
return nRet;
}
}
#endif
pStObj->nextTurn = TURN_BINARY_OPERATOR;
return SUCCESS;
}
static int pushOperator(StateObj *pStObj,QueryNode *pQuNode){
int nRet = 0;
pQuNode->type = OPERATOR;
switch (pQuNode->operator) {
case QPP_OP_NATURAL_BEGIN:
pStObj->natural_search = 1;
DEFAULT_OPERATOR_INSERTION();
pStObj->nextTurn = TURN_OPERAND;
break;
case QPP_OP_NATURAL_END:
pStObj->natural_search = 0;
pStObj->nextTurn = TURN_BINARY_OPERATOR;
break;
case QPP_OP_BEG_PHRASE:
pStObj->numPhraseOperand = 0;
DEFAULT_OPERATOR_INSERTION();
pStObj->nextTurn = TURN_OPERAND;
pStObj->posWithinPhrase = TRUE;
break;
case QPP_OP_END_PHRASE:
//susia insert : Empty "" fill fake operand
if (pStObj->numPhraseOperand == 0) {
stk_push(&(pStObj->postfixStack),&m_fakeQueryNode);
}
DEBUG("num operand %d",pStObj->numPhraseOperand);
pStObj->nextTurn = TURN_BINARY_OPERATOR;
pStObj->posWithinPhrase = FALSE;
nRet = pushPhrase(pStObj);
break;
case QPP_OP_BEG_PAREN:
DEFAULT_OPERATOR_INSERTION();
pStObj->nextTurn = TURN_OPERAND;
nRet = stk_push(&(pStObj->operatorStack),pQuNode);
break;
case QPP_OP_END_PAREN:
FAKE_OPERAND_INSERTION();
pStObj->nextTurn = TURN_BINARY_OPERATOR;
nRet = stk_moveTillParen(&(pStObj->operatorStack),&(pStObj->postfixStack));
if (nRet == FIELD_CLEAR) {
pStObj->searchField = -1;
pStObj->virtualfield = 0;
}
break;
case QPP_OP_FIELD:
DEFAULT_OPERATOR_INSERTION();
pStObj->virtualfield = 0;
pStObj->searchField = pQuNode->opParam;
nRet = pushGenericOperator(pStObj,pQuNode);
pStObj->nextTurn = TURN_OPERAND;
break;
case QPP_OP_VIRTUAL_FIELD:
DEFAULT_OPERATOR_INSERTION();
pStObj->virtualfield = pQuNode->opParam;
nRet = pushGenericOperator(pStObj,pQuNode);
pStObj->nextTurn = TURN_OPERAND;
break;
case QPP_OP_NOT:
DEFAULT_OPERATOR_INSERTION();
pStObj->nextTurn = TURN_OPERAND;
nRet = pushGenericOperator(pStObj,pQuNode);
default:
/// case QPP_OP_AND: // falls through
/// case QPP_OP_OR: // "" ""
/// case QPP_OP_NOT: // "" ""
/// case QPP_OP_PARA: // "" ""
/// case QPP_OP_WITHIN: // "" ""
/// case QPP_OP_FUZZY: // "" ""
// get rid of successive binary operator
// like "man AND & AND OR human" case
if (pStObj->nextTurn == TURN_OPERAND){
return SUCCESS;
}
pStObj->nextTurn = TURN_OPERAND;
nRet = pushGenericOperator(pStObj,pQuNode);
break;
}
DEBUG("pushOperator [%d] ret is [%d]",pQuNode->operator ,nRet);
return nRet;
}
static int pushBothEndBigram(void* word_db, StateObj *state, QueryNode *input_qnode)
{
index_word_extractor_t *extractor=NULL;
index_word_t indexwords[MAX_QPP_INDEXED_WORDS+2];/* dirty hack */
QueryNode within, qnode;
int num_of_words=0, i=0, rv=0;
char tmp_string[MAX_WORD_LEN];
strncpy(input_qnode->word_st.string, input_qnode->original_word, MAX_WORD_LEN-1);
input_qnode->word_st.string[MAX_WORD_LEN-1] = '\0';
DEBUG("original_word:%s, MAX_QPP_INDEXED_WORDS:%d",
input_qnode->original_word, MAX_QPP_INDEXED_WORDS);
extractor = sb_run_new_index_word_extractor(20);
if (extractor == NULL || extractor == (index_word_extractor_t*)MINUS_DECLINE) {
crit("error while allocating index word extractor");
return FAIL;
}
sb_run_index_word_extractor_set_text(extractor, input_qnode->original_word);
num_of_words = sb_run_get_index_words(extractor, indexwords, MAX_QPP_INDEXED_WORDS);
sb_run_delete_index_word_extractor(extractor);
if (num_of_words <= 0) {
INFO("num_of_words 0 for word:%s", input_qnode->original_word);
pushZeroWordid(state);
return SUCCESS;
}
DEBUG("num_of_words:%d", num_of_words);
bigram_word_copy(tmp_string, indexwords[0].word, MAX_WORD_LEN, 0);
snprintf(indexwords[num_of_words].word, MAX_WORD_LEN, "%s%s", "\\<", tmp_string);
indexwords[num_of_words].len = strlen(indexwords[num_of_words].word);
bigram_word_copy(tmp_string, indexwords[num_of_words-1].word,
MAX_WORD_LEN, 2);
snprintf(indexwords[num_of_words+1].word, MAX_WORD_LEN, "%s%s", tmp_string, "\\>");
indexwords[num_of_words+1].len = strlen(indexwords[num_of_words+1].word);
for (i=0; i<num_of_words+2; i++) {
strncpy(qnode.word_st.string, indexwords[i].word, MAX_WORD_LEN-1);
qnode.word_st.string[MAX_WORD_LEN-1] = '\0';
state->truncated = 1; // truncated is unset within pushOperand
if (i==0)
pushStarHackedOperand(word_db, state, &qnode,input_qnode->word_st.string);
else
pushOperandEmptyWord(word_db, state, &qnode);
}
within.type = OPERATOR;
within.operator = QPP_OP_WITHIN;
within.num_of_operands = num_of_words+2; // \< , \> added
within.opParam = 0;
rv = stk_push(&(state->postfixStack), &within);
if (rv < 0) {
error("error while pushing within operator into stack");
return FAIL;
}
if (state->posWithinPhrase == TRUE) {
state->numPhraseOperand++;
}
state->nextTurn = TURN_BINARY_OPERATOR;
return SUCCESS;
}
void elg_readcb_ENTER_TRACING(elg_ui4 lid, elg_d8 time,
elg_ui1 metc, elg_ui8 metv[], void* userdata) {
lid = locmap[lid];
stk_push(lid, 0, time);
}
/*
* 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);
}
