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 */