Alien-Judy
view release on metacpan or search on metacpan
src/judy-1.0.5/tool/jhton.c view on Meta::CPAN
// Warning: This cannot be used around compiler directives, such as
// "#include", nor in the case where Code contains a comma other than nested
// within parentheses or quotes.
#ifndef DEBUG
#define DBGCODE(Code) // null.
#else
#define DBGCODE(Code) Code
#endif
// ****************************************************************************
// MISCELLANEOUS GLOBAL VALUES:
#define FUNCTION // null; easy to find functions.
#define FALSE 0
#define TRUE 1
#define CHNULL ('\0')
#define PCNULL ((char *) NULL)
typedef int bool_t; // for clarity with Boolean values.
char * gc_usage[] = {
"usage: %s filename.htm[l]",
"",
"Reads restricted (Judy-specific) HTML from filename.htm[l] and emits",
"equivalent nroff -man to stdout.",
PCNULL,
};
char * gc_myname; // how program was invoked.
#define OKEXIT 0
#define NOEXIT 0 // values for Error().
#define ERREXIT 1
#define USAGE 2
#define NOERRNO 0
// Prefix for printf formats:
#define FILELINE "File \"%s\", line %d: "
// Common error string:
char * FmtErrLineEnds = FILELINE "Input line ends within an HTML tag; for this "
"translator, all tags must be on a single input line";
// Macros for skipping whitespace or non-whitespace; in the latter case,
// stopping at end of line or end of tag:
#define SKIPSPACE(Pch) { while (ISSPACE(*(Pch))) ++(Pch); }
#define SKIPNONSPACE(Pch) { while ((! ISSPACE(*(Pch))) \
&& (*(Pch) != CHNULL) \
&& (*(Pch) != '>')) ++(Pch); }
// Highest line number + 1, and last input line number that caused output:
int g_linenumlim;
int g_prevlinenum = 0;
// <PRE> block equivalents in nroff need some special handling for bold font
// and for continuing a tagged paragraph; these are bit flags:
#define INPRE_BLOCK 0x1 // came from <PRE>.
#define INPRE_BOLD 0x2 // came from <B><PRE>.
#define INPRE_INDENT 0x4 // under <DL> below top level.
// ****************************************************************************
// DOCUMENT NODE TYPES:
//
// If an HTML tag is not in this list, it's unrecognized and causes a fatal
// error. Otherwise the tag type (dn_type) is one of DN_TYPE_*, which are
// defined so the code can use them, but they MUST match the order of
// initialization of g_dntype[].
//
// Note: The default node type is DN_TYPE_TEXT, that is, text outside of any
// tag.
enum {
DN_TYPE_TEXT = 0,
DN_TYPE_HTML,
DN_TYPE_HEAD,
DN_TYPE_TITLE,
DN_TYPE_BODY,
DN_TYPE_COMM,
DN_TYPE_TABLE,
DN_TYPE_TR,
DN_TYPE_TD,
DN_TYPE_DL,
DN_TYPE_DT,
DN_TYPE_DD,
DN_TYPE_A,
DN_TYPE_B,
DN_TYPE_I,
DN_TYPE_PRE,
DN_TYPE_P,
DN_TYPE_BR
};
// Regarding dnt_nest: If an HTML tag type is marked as nesting, that means
// it is required not to be a singleton in this context; it must have a closing
// tag, and when the tree is built, the intervening text is nested as a child.
// Otherwise, intervening text is a sibling; a closing tag is allowed (whether
// or not this makes sense), but is not required; however, if present, it must
// match.
struct docnode_type {
char * dnt_tag; // HTML tag.
bool_t dnt_savetag; // flag: save HTML tag.
bool_t dnt_nest; // flag: see comments above.
int dnt_type; // corresponding number.
} g_dntype[] = {
// Note: HTML is case-insensitive, but for expediency this program is
// case-sensitive. Tags must be as shown below.
{ "", FALSE, FALSE, DN_TYPE_TEXT, }, // special, see above.
{ "HTML", FALSE, TRUE, DN_TYPE_HTML, },
{ "HEAD", FALSE, TRUE, DN_TYPE_HEAD, },
{ "TITLE", FALSE, TRUE, DN_TYPE_TITLE, },
{ "BODY", FALSE, TRUE, DN_TYPE_BODY, },
{ "!--", TRUE, FALSE, DN_TYPE_COMM, }, // comments are singleton tags.
{ "TABLE", FALSE, TRUE, DN_TYPE_TABLE, }, // limited understanding!
{ "TR", FALSE, TRUE, DN_TYPE_TR, },
{ "TD", TRUE, TRUE, DN_TYPE_TD, },
{ "DL", FALSE, TRUE, DN_TYPE_DL, },
{ "DT", FALSE, TRUE, DN_TYPE_DT, },
{ "DD", FALSE, FALSE, DN_TYPE_DD, }, // </DD> not req in our manuals.
{ "A", TRUE, TRUE, DN_TYPE_A, }, // either "name" or "href" type.
{ "B", FALSE, TRUE, DN_TYPE_B, },
{ "I", FALSE, TRUE, DN_TYPE_I, },
{ "PRE", FALSE, TRUE, DN_TYPE_PRE, },
{ "P", FALSE, FALSE, DN_TYPE_P, }, // </P> not req in our manuals.
{ "BR", FALSE, FALSE, DN_TYPE_BR, }, // </BR> not req in our manuals.
{ PCNULL, FALSE, FALSE, 0, }, // end of list.
};
// Convenience macros:
#define TAG(DN_Type) (g_dntype[DN_Type].dnt_tag)
#define SAVETAG(DN_Type) (g_dntype[DN_Type].dnt_savetag)
#define NEST(DN_Type) (g_dntype[DN_Type].dnt_nest)
// ****************************************************************************
// DOCUMENT NODE DATA STRUCTURES:
//
// Document nodes are saved in a doubly-linked tree of docnodes. Each docnode
// points sideways to a doubly-linked list of sibling docnodes for
// previous/successive unnested document objects, plus points to its parent and
// to the first of a sideways doubly-linked child list of nested objects. All
// data lives in malloc'd memory.
//
// The dn_text field is null for a tag node unless the tag text is worth
// saving. The field is non-null for non-tag (document) text.
typedef struct docnode * Pdn_t;
struct docnode {
int dn_type; // node type, index in g_dntype[].
int dn_linenum; // where introduced, for reconstructing.
bool_t dn_closed; // flag: closing tag was seen.
bool_t dn_noemit; // flag: skip on output, for marking ahead.
bool_t dn_bold; // flag: for <PRE>, whole section is bold.
char * dn_text; // node text; see above.
Pdn_t dn_Pprev; // previous node in sibling list.
Pdn_t dn_Pnext; // next node in sibling list.
Pdn_t dn_Pparent; // up-link to parent node, if any.
Pdn_t dn_Pchild; // down-link to first node in child subtree.
};
#define PDNNULL ((Pdn_t) NULL)
Pdn_t g_Pdnhead = PDNNULL; // head of docnode tree.
// ****************************************************************************
// FUNCTION SIGNATURES (forward declarations):
int main(int argc, char ** argv);
void ReadInputFile( char * Filename, FILE * PFile);
void CheckNesting(Pdn_t Pdn);
void EmitNroffHeader(char * Filename, char ** PPageName);
void EmitNroffBody(Pdn_t Pdn, int DLLevel, int InPRE, char * PageName);
void ExtractHeader( Pdn_t Pdn, char ** PFileRev,
char ** PPageName, char ** PPageSection,
char * PLcLetter, char ** PRevision);
char * ExtractText( Pdn_t Pdn);
void ExtractPageInfo(Pdn_t Pdn, char * Pch,
char ** PPageName, char ** PPageSection,
char * PLcLetter);
int TagType(char * Tag, bool_t * isclosing, char * Filename, int Linenum);
Pdn_t AppDocNode( Pdn_t Pdn, int linenum);
Pdn_t NewDocNode( Pdn_t dn_Pparent, int linenum);
char * SaveDocNode(Pdn_t Pdn, int DN_Type, char * Pch,
char * Filename, int Linenum);
bool_t ParentPre(Pdn_t Pdn, bool_t BoldOnly);
void MarkNoEmit( Pdn_t Pdn, bool_t Font);
void EmitText( char * Pch, int InPRE, int Linenum);
void EmitTextPRE( char * Pch, int InPRE);
void EmitTextBS( char * Pch);
bool_t NoWhiteSpace( char * Pch);
int CountNewlines(char * Pch);
char * StrSave( char * String);
char * StrSaveN( char * String, ...);
void * Malloc( size_t Size);
void Usage(void);
void Error(int Exitvalue, int MyErrno, char * Message, ...);
DBGCODE(void DumpTree(Pdn_t Pdn, int Depth, bool_t Separator);)
// ****************************************************************************
// M A I N
FUNCTION int main(
src/judy-1.0.5/tool/jhton.c view on Meta::CPAN
//
// Note: For a correct line number, SETPREV() must account for any newlines in
// the text just emitted.
#define SETPREV(Text) g_prevlinenum = (Pdn->dn_linenum) + CountNewlines(Text)
#define SETPREVNONL g_prevlinenum = g_linenumlim // no newline.
// Check if under a lower-level <DL>, for continuing an indented paragraph:
#define UNDER_DL ((DLLevel > 1) \
&& ((Pdn->dn_Pparent) != PDNNULL) \
&& ((Pdn->dn_Pparent->dn_type) == DN_TYPE_DL))
// SWITCH ON DOCNODE TYPE:
if (Pdn->dn_noemit) // upstream node said to skip this one.
goto NextNode;
switch (Pdn->dn_type)
{
// DOCUMENT TEXT:
//
// Just emit it with HTML escaped chars modified, with backslashes doubled,
// with no trailing newline, and if not within <PRE> text, with any leading
// whitespace deleted, so that, for example, something like "\fI text\fP" does
// not result.
case DN_TYPE_TEXT:
assert((Pdn->dn_text) != PCNULL);
CHECKPREV;
EmitText(Pdn->dn_text, InPRE, Pdn->dn_linenum);
SETPREV(Pdn->dn_text);
break;
// IGNORE THESE TYPES:
//
// See EmitNroffHeader() for nroff equivalents already emitted in some cases.
// In some cases, mark all child nodes no-emit to ignore them.
case DN_TYPE_HTML:
case DN_TYPE_HEAD:
case DN_TYPE_BODY:
case DN_TYPE_COMM: break;
case DN_TYPE_TITLE:
case DN_TYPE_TABLE:
case DN_TYPE_TR:
case DN_TYPE_TD:
MarkNoEmit(Pdn->dn_Pchild, /* Font = */ FALSE);
break;
// DESCRIPTIVE LIST:
//
// At the top level these represent manual entry sections, and any bold markers
// around the text are ignored. Below the top level these translate to tagged
// paragraphs. Here, just note the increment and continue the walk.
case DN_TYPE_DL:
DLcount = 1;
break;
// DESCRIPTIVE LIST TAG:
case DN_TYPE_DT:
assert(NEST(DN_TYPE_DT)); // tag text must be child.
if ((Pdn->dn_Pchild) == PDNNULL) // no child exists.
{
Error(ERREXIT, NOERRNO, "HTML tag \"%s\" found at input line "
"%d lacks text, which is required by this translator",
TAG(DN_TYPE_DT), Pdn->dn_linenum);
}
// Further handling depends on DLLevel as explained above:
if (DLLevel <= 1) // major manual section.
{
PUTS("\n.SH ");
if ((Pdn->dn_Pchild->dn_type) == DN_TYPE_B)
(Pdn->dn_Pchild->dn_noemit) = TRUE; // skip <B>...</B>.
}
// If a <DT> immediately follows a previous <DT>, use .PD 0 for the successive
// .TP to join lines:
else
{
if (((Pdn->dn_Pprev) != PDNNULL)
&& ((Pdn->dn_Pprev->dn_type) == DN_TYPE_DT))
{
PUTS("\n.PD 0\n");
suffix = "\n.PD\n";
}
PUTS("\n.TP 15\n.C ");
}
SETPREVNONL;
break;
// DESCRIPTIVE LIST DATUM:
//
// Just proceed to dump the embedded text.
case DN_TYPE_DD: break;
// ANCHOR:
//
// Ignore inbound ("name") anchors and process outbound ("href") anchor labels
// into appropriately highlighted text.
case DN_TYPE_A:
{
size_t len; // of substring.
Pdn_t Pdn2; // child node.
char * Pch; // place in text.
assert((Pdn->dn_text) != PCNULL);
if (strstr(Pdn->dn_text, "name=") != PCNULL) break;
if (strstr(Pdn->dn_text, "href=") == PCNULL)
{
Error(NOEXIT, NOERRNO, "Unrecognized HTML anchor type \"%s\" "
"at input line %d ignored; only \"name=\" and \"href=\" "
"are allowed by this translator",
Pdn->dn_text, Pdn->dn_linenum);
break;
}
// Check for nested text (anchor label):
//
// TBD: The error message lies a little. If the text is something like,
// "foo<B>bar</B>", it passes this test; and later, all font tags in the anchor
// label are marked no-emit; and any other embedded tags, who knows what
// happens?
if (((Pdn2 = Pdn->dn_Pchild)->dn_type) != DN_TYPE_TEXT)
{
Error(ERREXIT, NOERRNO, "HTML \"href\" anchor at input line "
"%d lacks a directly nested anchor label, with no "
"further nested tags; this translator cannot support "
"nested tags in anchor labels", Pdn->dn_linenum);
}
assert((Pdn2->dn_text) != PCNULL);
// If the anchor is within a <B><PRE>, do nothing special with fonts, as
// explained earlier:
if (ParentPre(Pdn, /* BoldOnly = */ TRUE)) break;
// Since anchor label text font will be forced in a moment, ignore any nested
// font directives so they don't mess up nroff:
MarkNoEmit(Pdn->dn_Pchild, /* Font = */ TRUE);
// See if anchor label appears to be a reference to the current page, to some
// other page, or else just make it italicized text:
//
// TBD: This is pretty shaky, hope it's close enough.
len = strlen(PageName);
if (strncmp(Pdn2->dn_text, PageName, len) == 0) // self-reference.
{
CHECKPREV;
PUTS("\\fB"); // bold font.
SETPREVNONL;
suffix = "\\fP"; // revert to previous font.
break;
}
// Contains '(' and no whitespace => appears to reference some other page:
//
// Emit revised, tagged anchor label text immediately.
if (((Pch = strchr(Pdn2->dn_text, '(')) != PCNULL)
&& NoWhiteSpace(Pdn2->dn_text))
{
CHECKPREV;
PUTS("\\fI"); // italic font.
*Pch = CHNULL; // terminate briefly.
PUTS(Pdn2->dn_text);
*Pch = '(';
PUTS("\\fP"); // revert to previous font.
PUTS(Pch);
SETPREV(Pdn2->dn_text);
(Pdn2->dn_noemit) = TRUE; // skip later.
break;
}
// Just make the anchor label italicized text:
CHECKPREV;
PUTS("\\fI"); // italic font.
SETPREVNONL;
suffix = "\\fP"; // revert to previous font.
break;
} // case DN_TYPE_A
// BOLD TEXT:
//
// If the first child is <PRE>, use a "hard" font change; otherwise an in-line
// change.
//
// Note: For <DT><B>, this node is already marked dn_noemit and not seen here.
//
// Note: For <B><PRE>, nroff seems to reset font upon .PP, so mark the bold
// for later emission.
case DN_TYPE_B:
if (((Pdn->dn_Pchild) != PDNNULL)
&& ((Pdn->dn_Pchild->dn_type) == DN_TYPE_PRE))
{
(Pdn->dn_Pchild->dn_bold) = TRUE; // see above.
break;
}
CHECKPREV;
PUTS("\\fB"); // bold font.
SETPREVNONL;
suffix = "\\fP"; // revert to previous font.
break;
// ITALIC TEXT:
case DN_TYPE_I:
CHECKPREV;
PUTS("\\fI"); // italic font.
SETPREVNONL;
suffix = "\\fP"; // revert to previous font.
break;
// PREFORMATTED TEXT:
//
// Emit prefix/suffix directives based on example in strchr(3C).
case DN_TYPE_PRE:
PUTS(UNDER_DL ? "\n.IP\n.nf\n.ps +1\n" : "\n.PP\n.nf\n.ps +1\n");
if (Pdn->dn_bold) PUTS(".ft B\n"); // deferred bold.
SETPREVNONL;
suffix = ((Pdn->dn_bold) ? "\n.ft P\n.ps\n.fi\n" : "\n.ps\n.fi\n");
// set for all children:
InPRE = INPRE_BLOCK
| ((Pdn->dn_bold) ? INPRE_BOLD : 0)
| (UNDER_DL ? INPRE_INDENT : 0);
break;
// PARAGRAPH BREAK:
//
// If the parent is a <DL> below the top level, use .IP to continue a .TP
// (tagged paragraph); otherwise emit a standard .PP.
case DN_TYPE_P:
PUTS(UNDER_DL ? "\n.IP\n" : "\n.PP\n");
SETPREVNONL;
break;
// LINE BREAK:
case DN_TYPE_BR: PUTS("\n.br\n"); SETPREVNONL; break;
// UNRECOGNIZED DOCNODE TYPE:
default:
Error(ERREXIT, NOERRNO, "Internal error: Unexpected docnode type "
"%d in docnodes tree", Pdn->dn_type);
} // end switch on dn_type
// VISIT CHILD AND SIBLING DOCNODES:
//
// If this was a <DL> here, pass an incremented value to child nodes, but not
// to sibling nodes.
NextNode:
if ((Pdn->dn_Pchild) != PDNNULL)
EmitNroffBody(Pdn->dn_Pchild, DLLevel + DLcount, InPRE, PageName);
if (suffix != PCNULL) PUTS(suffix);
if ((Pdn->dn_Pnext) != PDNNULL)
EmitNroffBody(Pdn->dn_Pnext, DLLevel, InPRE, PageName);
} // EmitNroffBody()
// ****************************************************************************
// E X T R A C T H E A D E R
//
// Given a current docnode and pointers to values to return, walk the entire
// docnode tree once, recursively, in-order (parent then child then sibling) to
// extract nroff header information. Find the first comment line, insist it
// contain "@\(#)", and put this in *PFileRev. Also find exactly one
// DN_TYPE_TABLE, containing exactly one DN_TYPE_TR, containing one DN_TYPE_TD
// containing "align=\"left\"" and one DN_TYPE_TD containing
// "align=\"center\"", and extract from these the nroff .TH pagename,
// pagesection, and lcletter, and nroff ]W variable revision string,
// respectively. Error out if anything goes wrong.
//
src/judy-1.0.5/tool/jhton.c view on Meta::CPAN
/*NOTREACHED*/
return(0); // make some compilers happy.
} // TagType()
// ****************************************************************************
// A P P D O C N O D E
//
// Given a current docnode tree node, the input file line number, and
// g_Pdnhead, create a new docnode, append it to the tree in the right place,
// and return a pointer to it, with g_Pdnhead updated if required:
//
// * If empty tree, insert new as head of tree.
//
// * Otherwise if current node nests and is not closed, insert as its child.
//
// * Otherwise insert as a sibling of the current node.
//
// Note: Most HTML tags are non-singletons and hence nest, but if the nesting
// doesn't make sense, too bad, it's not detected, at least not here.
FUNCTION Pdn_t AppDocNode(
Pdn_t Pdn, // current docnode tree node.
int Linenum) // in input file.
{
// No current tree, insert first node:
if (g_Pdnhead == PDNNULL)
return(g_Pdnhead = NewDocNode(PDNNULL, Linenum));
// Insert new node as child, with parent set to current node:
if (NEST(Pdn->dn_type) && (! (Pdn->dn_closed)))
return((Pdn->dn_Pchild) = NewDocNode(Pdn, Linenum));
// Insert new node as sibling with same parent:
(Pdn->dn_Pnext) = NewDocNode(Pdn->dn_Pparent, Linenum);
(Pdn->dn_Pnext->dn_Pprev) = Pdn;
return(Pdn->dn_Pnext);
} // AppDocNode()
// ****************************************************************************
// N E W D O C N O D E
//
// Malloc() a new docnode and initialize its fields except dn_type, with error
// checking. Set its parent to the given value.
FUNCTION Pdn_t NewDocNode(
Pdn_t dn_Pparent, // parent to record.
int Linenum) // in input file.
{
Pdn_t Pdn = (Pdn_t) Malloc(sizeof(struct docnode));
(Pdn -> dn_linenum) = Linenum;
(Pdn -> dn_closed) = FALSE;
(Pdn -> dn_noemit) = FALSE;
(Pdn -> dn_bold) = FALSE;
(Pdn -> dn_text) = PCNULL;
(Pdn -> dn_Pprev) = PDNNULL;
(Pdn -> dn_Pnext) = PDNNULL;
(Pdn -> dn_Pparent) = dn_Pparent;
(Pdn -> dn_Pchild) = PDNNULL;
return(Pdn);
} // NewDocNode()
// ****************************************************************************
// S A V E D O C N O D E
//
// Given a pointer to a docnode, the docnode type, a string for the current
// location (past tag name at whitespace or ">"), and a filename and line
// number for error reporting, save the docnode type in the node, and also save
// the tag text if appropriate; then find the end of the tag (">") and return
// past that location (possibly before more whitespace). Error out in case of
// syntax error.
FUNCTION char * SaveDocNode(
Pdn_t Pdn, // docnode to modify.
int DN_Type, // new type to save.
char * Pch, // current location past tagname.
char * Filename, // for error reporting.
int Linenum) // for error reporting.
{
char * Pch2 = PCNULL; // second location; init for gcc -Wall.
assert( Pch != PCNULL);
assert(*Pch != CHNULL);
// Save type:
(Pdn->dn_type) = DN_Type;
// Pass whitespace and then find the end of the tag:
SKIPSPACE(Pch);
if ((*Pch == CHNULL) || ((Pch2 = strchr(Pch, '>')) == PCNULL))
Error(ERREXIT, NOERRNO, FmtErrLineEnds, Filename, Linenum);
// Optionally save tag text:
if (SAVETAG(DN_Type))
{
*Pch2 = CHNULL; // temporarily terminate.
(Pdn->dn_text) = StrSave(Pch);
*Pch2 = '>';
}
return(Pch2 + 1);
} // SaveDocNode()
// ****************************************************************************
// P A R E N T P R E
//
// Given a docnode (can be null) and a flag whether only bold <PRE> is of
// interest, return TRUE if any of its parents is a <PRE> (marked for bold
// text), that is, DN_TYPE_PRE (with dn_bold set); otherwise return FALSE.
FUNCTION bool_t ParentPre(
Pdn_t Pdn, // starting node.
bool_t BoldOnly) // flag: only care about bold <PRE>.
{
if (Pdn == PDNNULL) return (FALSE); // no parent.
for (Pdn = Pdn->dn_Pparent; Pdn != PDNNULL; Pdn = Pdn->dn_Pparent)
{
if (((Pdn->dn_type) == DN_TYPE_PRE)
&& ((! BoldOnly) || (Pdn->dn_bold)))
{
return(TRUE);
}
}
return(FALSE);
} // ParentPre()
// ****************************************************************************
// M A R K N O E M I T
//
// Given a docnode (can be null), and a flag, recursively mark the node and all
// children and siblings as do-not-emit, unless the flag is set, only mark font
// docnodes.
FUNCTION void MarkNoEmit(
Pdn_t Pdn, // top node to mark.
bool_t Font) // flag: only mark font docnodes.
{
if (Pdn == PDNNULL) return;
if ((! Font)
|| ((Pdn->dn_type) == DN_TYPE_B)
|| ((Pdn->dn_type) == DN_TYPE_I))
{
(Pdn->dn_noemit) = TRUE;
}
if ((Pdn->dn_Pchild) != PDNNULL) MarkNoEmit(Pdn->dn_Pchild, Font);
if ((Pdn->dn_Pnext) != PDNNULL) MarkNoEmit(Pdn->dn_Pnext, Font);
} // MarkNoEmit()
// ****************************************************************************
// E M I T T E X T
//
// Given a text string, a bitflag for <PRE> status, and an input line number
// for error reporting, copy the text string to stdout with no added newlines,
// but translating selected HTML escape codes to simple characters, doubling
// any backslashes, and if InPRE, inserting .IP (if INPRE_INDENT) or .PP at
// blank lines (between successive newlines), and if INPRE_BOLD, putting back
// bold font since .IP/.PP seems to reset the font. Warn about unrecognized
// escape codes.
struct et_list {
char * et_escape; // expected text.
size_t et_len; // of expected text.
char et_emit; // equivalent char.
} et_list[] = {
{ "amp;", 4, '&', },
{ "gt;", 3, '>', },
{ "lt;", 3, '<', },
{ PCNULL, 0, ' ', }, // end of list.
};
FUNCTION void EmitText(
char * Pch, // text to emit.
int InPRE, // bitflag for <PRE> status.
int Linenum) // for error reporting.
{
char * Pch2; // place in text.
struct et_list * Pet; // place in et_list[].
while ((Pch2 = strchr(Pch, '&')) != PCNULL) // another escape code.
{
*Pch2 = CHNULL; // briefly terminate.
EmitTextPRE(Pch, InPRE); // emit preceding part.
*Pch2 = '&';
Pch = Pch2 + 1; // past '&'.
for (Pet = et_list; Pet->et_escape != PCNULL; ++Pet)
{
if (strncmp(Pch, Pet->et_escape, Pet->et_len) == 0)
{
PUTC(Pet->et_emit); // translate.
Pch += Pet->et_len; // skip escapecode.
break;
}
}
if (Pet->et_escape == PCNULL) // no match found.
{
Error(NOEXIT, NOERRNO, "Unrecognized HTML escape code in "
"line %d (or text beginning on that line): \"%.4s...\", "
"passed through unaltered", Linenum, Pch2);
PUTC('&'); // emit start of escape code.
// continue with Pch is just after the '&'.
}
}
EmitTextPRE(Pch, InPRE); // emit remaining part.
} // EmitText()
// ****************************************************************************
// E M I T T E X T P R E
//
// Given a text string with no HTML escape codes in it and a bitflag for <PRE>
// status (see EmitText()), emit the string with <PRE> handling, and with any
// backslashes doubled.
( run in 0.926 second using v1.01-cache-2.11-cpan-cdf2f3d4e48 )