void
CmdIntegral(int code)
/******************************************************************************
purpose: converts integral symbol + the "exponent" and "subscript" fields
parameter: type of operand
******************************************************************************/
{
char *upper_limit = NULL;
char *lower_limit = NULL;
char cThis;
/* is there an exponent/subscript ? */
cThis = getNonBlank();
if (cThis == '_')
lower_limit = getBraceParam();
else if (cThis == '^')
upper_limit = getBraceParam();
else
ungetTexChar(cThis);
if (upper_limit || lower_limit) {
cThis = getNonBlank();
if (cThis == '_')
lower_limit = getBraceParam();
else if (cThis == '^')
upper_limit = getBraceParam();
else
ungetTexChar(cThis);
}
fprintRTF(" \\\\I");
switch(code)
{
case 4 : fprintRTF("\\\\in( %c %c )\\\\I", g_field_separator, g_field_separator); /*\iiint --- fall through*/
case 3 : fprintRTF("\\\\in( %c %c )\\\\I", g_field_separator, g_field_separator); /* \iint --- fall through*/
case 0 : fprintRTF("\\\\in("); break;
case 1 : fprintRTF("\\\\su("); break;
case 2 : fprintRTF("\\\\pr("); break;
default: diagnostics(ERROR, "Illegal code to CmdIntegral");
}
if (lower_limit)
ConvertString(lower_limit);
fprintRTF("%c", g_field_separator);
if (upper_limit)
ConvertString(upper_limit);
fprintRTF("%c )", g_field_separator);
if (lower_limit)
free(lower_limit);
if (upper_limit)
free(upper_limit);
}
void
CmdLim(int code)
/******************************************************************************
purpose: handles \lim
parameter: 0=\lim, 1=\limsup, 2=\liminf
******************************************************************************/
{
char cThis, *s, *lower_limit=NULL;
cThis = getNonBlank();
if (cThis == '_')
lower_limit = getBraceParam();
else
ungetTexChar(cThis);
if (code == 0)
s=strdup("lim");
else if (code == 1)
s=strdup("lim sup");
else
s=strdup("lim inf");
if (lower_limit)
fprintRTF("\\\\a\\\\ac(");
fprintRTF("%s",s);
if (lower_limit) {
fprintRTF("%c",g_field_separator);
ConvertString(lower_limit);
fprintRTF(")");
}
free(s);
}
static char *
getAngleParam(void)
/******************************************************************************
purpose: return bracketed parameter
\item<1> ---> "1" \item<> ---> "" \item the ---> NULL
^ ^ ^
\item <1> ---> "1" \item <> ---> "" \item the ---> NULL
^ ^ ^
******************************************************************************/
{
char c, *text;
c = getNonBlank();
if (c == '<') {
text = getDelimitedText('<','>',TRUE);
diagnostics(5, "getAngleParam [%s]", text);
} else {
ungetTexChar(c);
text = NULL;
diagnostics(5, "getAngleParam []");
}
return text;
}
void
CmdIndex(int code)
/******************************************************************************
purpose: convert \index{classe!article@\textit{article}!section}
to {\xe\v "classe:{\i article}:section"}
******************************************************************************/
{
char cThis, *text, *r, *s, *t;
cThis = getNonBlank();
text = getDelimitedText('{', '}', TRUE);
diagnostics(4, "CmdIndex \\index{%s}", text);
fprintRTF("{\\xe{\\v ");
t = text;
while (t) {
s = t;
t = strchr(s,'!');
if (t) *t = '\0';
r = strchr(s,'@');
if (r) s=r+1;
ConvertString(s);
/* while (*s && *s != '@') putRtfChar(*s++);*/
if (t) {
fprintRTF("\\:");
t++;
}
}
fprintRTF("}}");
diagnostics(4, "leaving CmdIndex");
free(text);
}
/* lex - a simple lexical analyzer for arithmetic
expressions */
int lex() {
lexLen = 0;
getNonBlank();
switch (charClass) {
/* Parse identifiers */
case LETTER:
addChar();
getChar();
while (charClass == LETTER || charClass == DIGIT) {
addChar();
prevClass = charClass;
getChar();
}
nextToken = IDENT;
break;
/* Parse integer literals */
case DIGIT:
addChar();
getChar();
while (charClass == DIGIT) {
addChar();
getChar();
}
nextToken = INT_LIT;
break;
/* Parentheses and operators */
case UNKNOWN:
lookup(nextChar);
getChar();
if (prevToken == 24 && nextToken == 23) {
addChar();
getChar();
}
else if (prevToken == 23 && nextToken == 24) {
addChar();
getChar();
}
break;
/* EOF */
case EOF:
nextToken = EOF;
lexeme[0] = 'E';
lexeme[1] = 'O';
lexeme[2] = 'F';
lexeme[3] = 0;
break;
} /* End of switch */
if (prevToken == 24 && nextToken == 23)
{printf("Comment detected! \n");}
else if (prevToken == 23 && nextToken == 24)
{printf("End of Comment detected! \n");}
else if (prevClass == DIGIT && (charClass == LETTER || nextToken == SUB_OP))
{printf("Floating point detected! \n");}
printf("Next token is: %d, Next lexeme is %s\n",
nextToken, lexeme);
//prevToken = nextToken;
return nextToken;
} /* End of function lex */
int lex(){
lexLen = 0;
getNonBlank();
switch (charClass) {
case LETTER:
addChar();
getChar();
while (charClass==LETTER || charClass==DIGIT){
addChar();
getChar();
}
nextToken=IDENT;
break;
case DIGIT:
addChar();
getChar();
while (charClass==DIGIT){
addChar();
getChar();
}
nextToken=INT_LIT;
break;
case UNKNOWN:
lookup(nextChar);
getChar();
break;
case EOF:
nextToken=EOF;
lexeme[0]='E';
lexeme[1]='O';
lexeme[2]='F';
lexeme[3]=0;
break;
}
i=0;
while(i<3){
if(strcmp(lexeme,storge[i])==0 || strcmp(lexeme,types[i])==0){
if(strcmp(lexeme,storge[i])==0){
printf("El token pertenece a lexema\n");
}else{
printf("El token pertenece a type\n");
}
}
i++;
}
return nextToken;
}
/* lex - a simple lexical analyzer for arithmetic expressions */
void lex() {
getNonBlank();
switch (charClass) {
case LETTER:
break;
case UNKNOWN:
error("Only lower case letter can be parsed. Cannot parse " + nextChar);
while (charClass != LETTER)
getChar();
break;
/* EOF */
case EOF:
nextChar = EOF;
break;
} /* End of switch */
printf("Next char is %s\n", nextChar);
} /* End of function lex */
void
CmdBibitem(int code)
{
char *label, *key, *signet, *s, c;
g_processing_list_environment=TRUE;
CmdEndParagraph(0);
CmdStartParagraph(FIRST_PAR);
label = getBracketParam();
key = getBraceParam();
signet = strdup_nobadchars(key);
s=ScanAux("bibcite", key, 0);
if (label && !s) { /* happens when file needs to be latex'ed again */
diagnostics(WARNING,"file needs to be latexed again for references");
fprintRTF("[");
ConvertString(label);
fprintRTF("]");
} else {
diagnostics(4,"CmdBibitem <%s>",s);
if (g_document_bibstyle == BIBSTYLE_STANDARD) {
// fprintRTF("[");
fprintRTF("{\\v\\*\\bkmkstart BIB_%s}",signet);
ConvertString(s);
fprintRTF("{\\*\\bkmkend BIB_%s}",signet);
// fprintRTF("]");
fprintRTF(".");
fprintRTF("\\tab ");
}
/* else emit nothing for APALIKE */
}
if (s) free(s);
if (label) free(label);
free(signet);
free(key);
c=getNonBlank();
ungetTexChar(c);
}
void
Convert()
/****************************************************************************
purpose: converts inputfile and writes result to outputfile
globals: fTex, fRtf and all global flags for convert (see above)
****************************************************************************/
{
char cThis = '\n';
char cLast = '\0';
char cNext;
int mode, count,pending_new_paragraph;
diagnostics(3, "Entering Convert ret = %d", ret);
RecursionLevel++;
PushLevels();
while ((cThis = getTexChar()) && cThis != '\0') {
if (cThis == '\n')
diagnostics(5, "Current character is '\\n' mode = %d ret = %d level = %d", GetTexMode(), ret, RecursionLevel);
else
diagnostics(5, "Current character is '%c' mode = %d ret = %d level = %d", cThis, GetTexMode(), ret, RecursionLevel);
mode = GetTexMode();
pending_new_paragraph--;
switch (cThis) {
case '\\':
PushLevels();
TranslateCommand();
CleanStack();
if (ret > 0) {
diagnostics(5, "Exiting Convert via TranslateCommand ret = %d level = %d", ret, RecursionLevel);
ret--;
RecursionLevel--;
return;
}
break;
case '{':
if (mode==MODE_VERTICAL) SetTexMode(MODE_HORIZONTAL);
CleanStack();
PushBrace();
fprintRTF("{");
break;
case '}':
CleanStack();
ret = RecursionLevel - PopBrace();
fprintRTF("}");
if (ret > 0) {
diagnostics(5, "Exiting Convert via '}' ret = %d level = %d", ret, RecursionLevel);
ret--;
RecursionLevel--;
return;
}
break;
case ' ':
if (mode==MODE_VERTICAL || mode==MODE_MATH || mode==MODE_DISPLAYMATH)
cThis = cLast;
else if ( cLast != ' ' && cLast != '\n' ) {
if (GetTexMode()==MODE_RESTRICTED_HORIZONTAL)
fprintRTF("\\~");
else
fprintRTF(" ");
}
break;
case '\n':
tabcounter = 0;
if (mode==MODE_MATH || mode==MODE_DISPLAYMATH) {
cNext = getNonBlank();
ungetTexChar(cNext);
} else {
cNext = getNonSpace();
if (cNext == '\n') { /* new paragraph ... skip all ' ' and '\n' */
pending_new_paragraph=2;
CmdEndParagraph(0);
cNext = getNonBlank();
ungetTexChar(cNext);
} else { /* add a space if needed */
ungetTexChar(cNext);
if (mode != MODE_VERTICAL && cLast != ' ')
fprintRTF(" ");
}
}
break;
case '$':
cNext = getTexChar();
diagnostics(5,"Processing $, next char <%c>",cNext);
if (cNext == '$' && GetTexMode() != MODE_MATH)
CmdEquation(EQN_DOLLAR_DOLLAR | ON);
else {
ungetTexChar(cNext);
CmdEquation(EQN_DOLLAR | ON);
}
/*
Formulas need to close all Convert() operations when they end
This works for \begin{equation} but not $$ since the BraceLevel
and environments don't get pushed properly. We do it explicitly here.
*/
/*
if (GetTexMode() == MODE_MATH || GetTexMode() == MODE_DISPLAYMATH)
PushBrace();
else {
ret = RecursionLevel - PopBrace();
if (ret > 0) {
ret--;
RecursionLevel--;
diagnostics(5, "Exiting Convert via Math ret = %d", ret);
return;
}
}
*/
break;
case '&':
if (g_processing_arrays) {
fprintRTF("%c",g_field_separator);
break;
}
if (GetTexMode() == MODE_MATH || GetTexMode() == MODE_DISPLAYMATH) { /* in eqnarray */
fprintRTF("\\tab ");
g_equation_column++;
break;
}
if (g_processing_tabular) { /* in tabular */
actCol++;
fprintRTF("\\cell\\pard\\intbl\\q%c ", colFmt[actCol]);
break;
}
fprintRTF("&");
break;
case '~':
fprintRTF("\\~");
break;
case '^':
CmdSuperscript(0);
break;
case '_':
CmdSubscript(0);
break;
case '-':
if (mode == MODE_MATH || mode == MODE_DISPLAYMATH)
fprintRTF("-");
else {
SetTexMode(MODE_HORIZONTAL);
count = getSameChar('-')+1;
if (count == 1)
fprintRTF("-");
else if (count == 2)
fprintRTF("\\endash ");
else if (count == 3)
fprintRTF("\\emdash ");
else
while (count--) fprintRTF("-");
}
break;
case '|':
if (mode == MODE_MATH || mode == MODE_DISPLAYMATH)
fprintRTF("|");
else
fprintRTF("\\emdash ");
break;
case '\'':
if (mode == MODE_MATH || mode == MODE_DISPLAYMATH)
fprintRTF("'");
else {
SetTexMode(MODE_HORIZONTAL);
count = getSameChar('\'')+1;
if (count == 2)
fprintRTF("\\rdblquote ");
else
while (count--) fprintRTF("\\rquote ");
}
break;
case '`':
SetTexMode(MODE_HORIZONTAL);
count = getSameChar('`')+1;
if (count == 2)
fprintRTF("\\ldblquote ");
else
while (count--) fprintRTF("\\lquote ");
break;
case '\"':
SetTexMode(MODE_HORIZONTAL);
if (GermanMode)
TranslateGerman();
else
fprintRTF("\"");
break;
case '<':
if (mode == MODE_VERTICAL) SetTexMode(MODE_HORIZONTAL);
if (GetTexMode() == MODE_HORIZONTAL){
cNext = getTexChar();
if (cNext == '<') {
if (FrenchMode) { /* not quite right */
skipSpaces();
cNext = getTexChar();
if (cNext == '~')
skipSpaces();
else
ungetTexChar(cNext);
fprintRTF("\\'ab\\~");
} else
fprintRTF("\\'ab");
} else {
ungetTexChar(cNext);
fprintRTF("<");
}
} else
fprintRTF("<");
break;
case '>':
if (mode == MODE_VERTICAL) SetTexMode(MODE_HORIZONTAL);
if (GetTexMode() == MODE_HORIZONTAL){
cNext = getTexChar();
if (cNext == '>')
fprintRTF("\\'bb");
else {
ungetTexChar(cNext);
fprintRTF(">");
}
} else
fprintRTF(">");
break;
case '!':
if (mode == MODE_MATH || mode == MODE_DISPLAYMATH)
fprintRTF("!");
else {
SetTexMode(MODE_HORIZONTAL);
if ((cNext = getTexChar()) && cNext == '`') {
fprintRTF("\\'a1 ");
} else {
fprintRTF("! ");
ungetTexChar(cNext);
}
}
break;
case '?':
SetTexMode(MODE_HORIZONTAL);
if ((cNext = getTexChar()) && cNext == '`') {
fprintRTF("\\'bf ");
} else {
fprintRTF("? ");
ungetTexChar(cNext);
}
break;
case ':':
if (mode == MODE_MATH || mode == MODE_DISPLAYMATH)
fprintRTF(":");
else {
SetTexMode(MODE_HORIZONTAL);
if (FrenchMode)
fprintRTF("\\~:");
else
fprintRTF(":");
}
break;
case '.':
if (mode == MODE_MATH || mode == MODE_DISPLAYMATH)
fprintRTF(".");
else {
SetTexMode(MODE_HORIZONTAL);
fprintRTF(".");
/* try to simulate double spaces after sentences */
cNext = getTexChar();
if (0 && cNext == ' ' && (isalpha((int)cLast) && !isupper((int) cLast)))
fprintRTF(" ");
ungetTexChar(cNext);
}
break;
case '\t':
diagnostics(WARNING, "This should not happen, ignoring \\t");
cThis = ' ';
break;
case '\r':
diagnostics(WARNING, "This should not happen, ignoring \\r");
cThis = ' ';
break;
case '%':
diagnostics(WARNING, "This should not happen, ignoring %%");
cThis = ' ';
break;
case '(':
if (g_processing_fields&&g_escape_parent)
fprintRTF("\\\\(");
else
fprintRTF("(");
break;
case ')':
if (g_processing_fields&&g_escape_parent)
fprintRTF("\\\\)");
else
fprintRTF(")");
break;
case ';':
if (g_field_separator == ';' && g_processing_fields)
fprintRTF("\\\\;");
else
if (FrenchMode)
fprintRTF("\\~;");
else
fprintRTF(";");
break;
case ',':
if (g_field_separator == ',' && g_processing_fields)
fprintRTF("\\\\,");
else
fprintRTF(",");
break;
default:
if (mode == MODE_MATH || mode == MODE_DISPLAYMATH) {
if (('a' <= cThis && cThis <= 'z') || ('A' <= cThis && cThis <= 'Z'))
fprintRTF("{\\i %c}", cThis);
else
fprintRTF("%c", cThis);
} else {
SetTexMode(MODE_HORIZONTAL);
fprintRTF("%c", cThis);
}
break;
}
tabcounter++;
cLast = cThis;
}
RecursionLevel--;
diagnostics(5, "Exiting Convert via exhaustion ret = %d", ret);
}
int lex() {
lexLen = 0;
getNonBlank();
switch (charClass) {
case LETTER:
addChar();
addChar1();
getChar();
while (charClass == LETTER){
addChar();
addChar1();
getChar();
}
nextToken = IDENT;
break;
case ADD:
addChar();
addChar1();
getChar();
while (charClass == ADD){
addChar();
addChar1();
getChar();
}
nextToken = ADD_OP;
break;
case DIV:
addChar();
addChar1();
getChar();
while (charClass == DIV){
addChar();
addChar1();
getChar();
}
nextToken = DIV_OP;
break;
case SUB:
addChar();
addChar1();
getChar();
while (charClass == SUB){
addChar();
addChar1();
getChar();
}
nextToken = SUB_OP;
break;
case MOD:
addChar();
addChar1();
getChar();
while (charClass == MOD){
addChar();
addChar1();
getChar();
}
nextToken = MOD_OP;
break;
case MUL:
addChar();
addChar1();
getChar();
while (charClass == MUL){
addChar();
addChar1();
getChar();
}
nextToken = MULT_OP;
break;
case DIGIT:
addChar();
getChar();
while (charClass == DIGIT) {
addChar();
getChar();
}
nextToken = INT_LIT;
break;
case LEFT:
addChar();
getChar();
while (charClass == LEFT) {
addChar();
getChar();
}
nextToken = LEFT_PAREN;
break;
case RIGHT:
addChar();
getChar();
while (charClass == RIGHT) {
addChar();
getChar();
}
nextToken = RIGHT_PAREN;
break;
case EOF:
nextToken = EOF;
lexeme[0] = 'E';
lexeme[1] = 'O';
lexeme[2] = 'F';
lexeme[3] = 0;
break;
}
////////////////////////////////////////////////////////////////////
if(nextToken == 21)
printf("ADD<term>\n");
else if(nextToken == 22)
printf("\n<expr>SUB<term>\n");
else if(nextToken == 23)
printf("MUL<factor>\n");
else if(nextToken == 24)
printf("DIV<factor>\n");
else if(nextToken == 25)
printf("MOD<factor>\n");
else if(nextToken == 26)
printf("\n( <expr> )\n");
else if(nextToken == 27)
{
printf("\n");
}
else if(nextToken == EOF)
printf("\n\n");
else
printf("<id>");
return nextToken;
}
/* lex - a simple lexical analyzer for arithmetic
expressions */
int lex() {
lexLen = 0;
int contar_punto = 0;
int contar_letra = 0;
int contar_numero =0;
getNonBlank();
switch (charClass) {
/* Parse identifiers */
case LETTER:
addChar();
getChar();
while (charClass == LETTER ) {
addChar();
getChar();
}
nextToken = IDENT;
break;
/* Parse integer literals */
case DIGIT:
addChar();
getChar();
while (charClass == DIGIT || charClass == PUNTO || charClass == LETTER) {
if (charClass == PUNTO) {
contar_punto++;
}
if (charClass == LETTER){
contar_letra++;
}
if (charClass == DIGIT){
contar_numero++;
}
addChar();
getChar();
}
if (contar_punto == 1 && contar_letra ==0) {
nextToken = FLOAT_LIT;
} else if (contar_punto > 1 || contar_letra >0) {
nextToken = UNKNOWN;
} else {
nextToken = INT_LIT;
}
break;
/* Parentheses and operators */
case UNKNOWN:
lookup(nextChar);
getChar();
break;
/* EOF */
case EOF:
nextToken = EOF;
lexeme[0] = 'E';
lexeme[1] = 'O';
lexeme[2] = 'F';
lexeme[3] = 0;
break;
}
printf("Next token is: %d, Next lexeme is %s\n", nextToken, lexeme);
return nextToken;
}
void lex() {
lexLen = 0;
getNonBlank();
switch (charClass) {
case LETTER:
addChar();
getChar();
while(charClass == LETTER || charClass == DIGIT) {
addChar();
getChar();
}
nextToken = IDENT;
break;
case DIGIT:
addChar();
getChar();
while(charClass == DIGIT) {
addChar();
getChar();
}
nextToken = INT_LIT;
break;
case UNKNOWN:
addChar();
switch (nextChar) {
case '(':
nextToken = LEFT_PAREN;
break;
case ')':
nextToken = RIGHT_PAREN;
break;
case '=':
nextToken = ASSIGN_OP;
break;
case '+':
nextToken = ADD_OP;
break;
case '-':
nextToken = SUB_OP;
break;
case '*':
nextToken = MULT_OP;
break;
case '/':
nextToken = DIV_OP;
break;
default:
nextToken = EOF;
break;
}
getChar();
break;
case EOF:
nextToken = EOF;
lexeme[0] = 'E';
lexeme[1] = 'O';
lexeme[2] = 'F';
lexeme[3] = 0;
break;
}
printf("token: %d - lexeme: %s\n", nextToken, lexeme);
}
int lex() {
lexLen = 0;
getNonBlank();
switch (charClass) {
/* Parse identifiers */
case LETTER:
addChar();
getChar();
while (charClass == LETTER || charClass == DIGIT) {
addChar();
getChar();
}
nextToken = IDENT;
break;
/* Parse integer literals */
case DIGIT:
addChar();
getChar();
while (charClass == DIGIT)
{
addChar();
getChar();
}
if(nextChar=='.')
{
getChar();
while (charClass == DIGIT)
{
addChar();
getChar();
}
if(charClass == LETTER)
{
addChar();
getChar();
while (charClass == LETTER || charClass == DIGIT)
{
addChar();
getChar();
}
nextToken = UNKNOWN;
}
else nextToken = FLOAT;
}
else if(charClass == LETTER)
{
addChar();
getChar();
while (charClass == LETTER || charClass == DIGIT) {
addChar();
getChar();
}
nextToken = UNKNOWN;
}
else nextToken = INT_LIT;
break;
/* Parentheses and operators */
case UNKNOWN:
lookup(nextChar);
getChar();
break;
/* EOF */
case EOF:
nextToken = EOF;
lexeme[0] = 'E';
lexeme[1] = 'O';
lexeme[2] = 'F';
lexeme[3] = 0;
break;
} /* End of switch */
printf("Next token is: %d, Next lexeme is %s\n",nextToken, lexeme);
return nextToken;
} /* End of function lex */
