static VOID append_docname(EXPSTR * prjstr, STRPTR docname)
{
app_estr(prjstr, LINE_DOCUMENT_STR);
app_estr(prjstr, " ");
append_string(prjstr, docname);
app_estr(prjstr, "\n");
}
static VOID append_id(EXPSTR * prjstr, STRPTR id)
{
app_estr(prjstr, LINE_ID_STR);
app_estr(prjstr, " ");
append_string(prjstr, id);
app_estr(prjstr, "\n");
}
/*
** handle_macro
**
** handle for macro: add local attributes to global attributes,
** include macro text, remove local attributes
**
** params: open_mac..TRUE, if called by an opening macro
** inpf......input file
*/
BOOL handle_macro( BOOL open_mac, INFILE *inpf, HSCTAG *macro )
{
BOOL ok = FALSE;
EXPSTR *text; /* macro text */
EXPSTR *fname; /* pseudo-filename */
DLLIST *args;
ULONG mci = get_mci();
/* determine filename & args */
args = macro->attr;
if ( open_mac ) {
text = macro->op_text ;
} else {
text = macro->cl_text ;
}
fname = init_estr( 0 );
if ( fname ) {
/* debugging message */
DMC( {
fprintf( stderr, "**-MACRO <" );
if ( !open_mac )
fprintf( stderr, "/" );
fprintf( stderr, "%s> from %p\n", macro->name, text );
} );
/* create pseudo-filename */
ok = set_estr( fname, "[macro " );
ok &= app_estr( fname, macro->name );
ok &= app_estr( fname, "]" );
}
/* replace icon-entity by image */
static VOID replace_icon(HSCPRC * hp, STRPTR icon)
{
INFILEPOS *base = new_infilepos(hp->inpf);
EXPSTR *image = init_estr(0);
STRPTR s = estr2str(hp->iconbase);
/* create string like <IMG SRC=":icons/back.gif" ALT="back"> */
set_estr(image, "<IMG SRC=\"");
/* use iconbase with "*" replaced by iconname as uri */
while (s[0])
{
if (s[0] == '*')
app_estr(image, icon);
else
app_estrch(image, s[0]);
s++;
}
/* set ALT attribute to iconname */
app_estr(image, "\" ALT=\"");
app_estr(image, icon);
app_estr(image, "\">");
hsc_message(hp, MSG_RPLC_ICON, "replacing icon-%e", icon);
hsc_include_string(hp, SPECIAL_FILE_ID "include icon",
estr2str(image),
IH_PARSE_HSC | IH_NO_STATUS | IH_POS_PARENT);
del_estr(image);
del_infilepos(base);
}
static VOID msg_idname(EXPSTR * msgstr, CONSTRPTR idname)
{
app_estr(msgstr, "id ");
app_estr(msgstr, "\"#");
app_estr(msgstr, idname);
app_estrch(msgstr, '"');
}
static VOID append_iddef(EXPSTR * prjstr, HSCIDD * iddef)
{
app_estr(prjstr, LINE_ID_STR);
app_estr(prjstr, " ");
append_string(prjstr, iddef->name);
append_caller(prjstr, iddef->caller);
app_estr(prjstr, "\n");
}
static VOID append_title(EXPSTR * prjstr, STRPTR title)
{
if (title)
{
app_estr(prjstr, LINE_TITLE_STR);
app_estr(prjstr, " ");
append_string(prjstr, title);
app_estr(prjstr, "\n");
}
}
static VOID append_sourcename(EXPSTR * prjstr, STRPTR sourcename)
{
if (sourcename)
{
app_estr(prjstr, LINE_SOURCE_STR);
app_estr(prjstr, " ");
append_string(prjstr, sourcename);
app_estr(prjstr, "\n");
}
}
static VOID append_include(EXPSTR * prjstr, HSCINC * include)
{
app_estr(prjstr, LINE_INCLUDE_STR);
app_estr(prjstr, " ");
append_string(prjstr, include->name);
append_caller(prjstr, include->caller);
app_estr(prjstr, "\n");
#if 0
DP(fprintf(stderr, DHP " include `%s'\n", include->name));
#endif
}
static VOID append_reference(EXPSTR * prjstr, HSCREF * reference)
{
#if 1
app_estr(prjstr, LINE_REFERENCE_STR);
app_estr(prjstr, " ");
append_string(prjstr, reference->name);
append_caller(prjstr, reference->caller);
app_estr(prjstr, "\n");
#else
DP(fprintf(stderr, DHP " refers `%s'\n", reference->name));
#endif
}
/*
* conv_uri2path
*
* convert a uri to a path for local (system-dependant)
* file system
*/
VOID conv_uri2path(EXPSTR * dest, STRPTR uri, BOOL weenix)
{
clr_estr(dest);
#ifdef AMIGA
if (weenix)
{
/* convert leading "/" to ":" */
/* convert leading "~" to ":" */
if (!strncmp(uri, "/", 1)
|| !strncmp(uri, "~/", 2)
|| !strncmp(uri, "~", 1))
{
app_estr(dest, ":");
uri++;
}
}
/* convert leading "../" to "/" */
while (!strncmp(uri, PARENT_URI, strlen(PARENT_URI)))
{
app_estr(dest, PARENT_DIR);
uri += strlen(PARENT_URI);
}
/* convert inside "../" to "//" */
while (uri[0])
{
if (!strncmp(uri, PARENT_URI, strlen(PARENT_URI)))
{
app_estrch(dest, '/');
uri += strlen(PARENT_URI);
}
else
{
app_estrch(dest, uri[0]);
uri++;
}
}
#elif defined RISCOS
set_estr(dest, uri);
#elif defined MSDOS /* dos2 */
#elif (defined NEXTSTEP) || (defined BEOS) || (defined UNIX)
set_estr(dest, uri);
#else
#error "system not supported: conv_uri2path"
#endif
}
/*
* hsc_write_project_file
*
* write ids to file
*/
static VOID append_ulong(EXPSTR * dest, ULONG num)
{
STRARR lenbuf[20];
sprintf(lenbuf, "%lx ", num);
app_estr(dest, lenbuf);
}
/*
* hsc_read_prefs
*
* try to open (any) config file and read preferences
* from it
*/
static BOOL hsc_read_prefs(HSCPRC * hp, STRPTR prefs_fname)
{
BOOL ok = FALSE;
EXPSTR *prefs_name_buffer = init_estr(32);
/* find prefs file */
if (!prefs_fname)
prefs_fname = find_prefs_fname(hp, prefs_name_buffer);
/* status message */
if (prefs_fname) {
dbg_disable(hp);
hsc_status_file_begin(hp, prefs_fname);
ok = hsc_include_file(hp, prefs_fname,
IH_PARSE_HSC | IH_NO_STATUS);
dbg_restore(hp);
if (ok) {
EXPSTR *msg = init_estr(32);
set_estr(msg, prefs_fname);
app_estr(msg, ": preferences read");
hsc_status_misc(hp, estr2str(msg));
del_estr(msg);
}
} else hsc_message(hp, MSG_NO_CONFIG,
"can not open preferences file");
del_estr(prefs_name_buffer);
return (ok);
}
/*
* define_attr_by_text
*
* define a new attribute with attribute definition passed as
* string. The new attribute is assigned to the global attr-list
* (by default, with a local scope)
*
* params: varname..name of new var
* flag.....flags: VF_ONLYONCE to avoid re-definition of a var
* result: ptr to new var
*
* NOTE:
* The new attribute will be declared as if a corresponding
* <$define> showed up in the source. It will be assigned to
* the local scope; you will need to add a "/GLOBAL" to the
* description text if you want to avoid this
*
* It's recommended not to setup a default value, if you are
* not sure that it can't contain data that will cause error
* messages to show up (like value=xy"zw'bl)
*
* definition syntax in input file:
* <varname>":"<vartype>[/flag]["="<deftext value>]
*
* EXAMPLE:
* define_attr_by_text(hp,"sepp:string/global='sepp'", 0)
*
* SEE ALSO:
* define_var()
*/
HSCATTR *define_attr_by_text(HSCPRC * hp, STRPTR attr_text, STRPTR default_value, ULONG unmasked_flags)
{
/* NOTE: this functions works a bit strange */
EXPSTR *define_text = init_estr(0);
INFILE *old_inpf = hp->inpf;
HSCATTR *attr = NULL;
/* create attribute definition */
set_estr(define_text, attr_text);
app_estr(define_text, ">");
hp->inpf = infopen_str(PARENT_FILE_ID "define_attr_by_text",
estr2str(define_text), 0);
/* process attribute definition */
if (hp->inpf)
{
attr = define_attr_by_hp(hp, default_value, unmasked_flags);
infclose(hp->inpf);
}
/* cleanup */
hp->inpf = old_inpf;
del_estr(define_text);
return (attr);
}
/*
* conv_path2uri
*
* convert a path for local (system-dependant)
* file system to URI
*/
VOID conv_path2uri(EXPSTR * dest, STRPTR path)
{
clr_estr(dest);
#ifdef AMIGA
/* replace leading parent directories by "../" */
while (!strncmp(path, PARENT_DIR, strlen(PARENT_DIR)))
{
app_estr(dest, PARENT_URI);
path += strlen(PARENT_DIR);
}
while (path[0])
{
/* replace all "//" by "../" */
if ((path[0] == '/') && (path[1] == '/'))
{
app_estr(dest, PARENT_URI);
path += 2;
}
else
{
app_estrch(dest, path[0]);
path++;
}
}
#elif defined MSDOS
/* replace all "\" by "/" */
while (path[0])
{
if ((path[0] == '\\'))
app_estrch(dest, '/');
else
app_estrch(dest, path[0]);
path++;
}
#elif defined UNIX
/* simply copy path */
set_estr(dest, path);
#else
#error "system not supported: conv_path2uri"
#endif
}
/*
* skip_until_eot
*
* skip until end of tag reached (">" found)
*
* params: inpf..input file
* result: TRUE, if no fatal error
* errors: return FALSE
*/
BOOL skip_until_eot(HSCPRC * hp, EXPSTR * logstr)
{
INFILE *inpf = hp->inpf;
STRPTR nw = NULL;
do
{
nw = infgetw(inpf);
if (nw && logstr)
{
app_estr(logstr, infgetcws(inpf));
app_estr(logstr, infgetcw(inpf));
}
}
while (nw && strcmp(nw, ">"));
return ((BOOL) ! (hp->fatal));
}
/*
* find_prefs_fname
*
* find preferences file: first check, if it is located
* somewhere in the paths given via CONFIG_PATH (which
* is a system depandent symbol); if not, check if it
* is in the path described in the envvar HSCPREFS
*
* result: full path & filename of prefs or NULL if not found
*
*/
static STRPTR find_prefs_fname(HSCPRC * hp, EXPSTR *cfgfn)
{
#define ENV_HOME "HOME"
STRPTR prefs_fname = NULL;
STRPTR paths[] = /* paths to search for config file */
{"", "", "", CONFIG_PATH,
NULL, NULL};
STRPTR path = NULL;
UBYTE path_ctr = 0;
FILE *cfgf = NULL; /* prefs file */
EXPSTR *hscpathstr = init_estr(32); /* buffer to read $HSCPATH */
EXPSTR *homepathstr = init_estr(32); /* buffer to read $HOME */
/* add "$HSCPATH/hsc.prefs" to files-to-be-checked */
if (link_envfname(hscpathstr, ENV_HSCPATH, NULL, NULL))
{
/* add envval to paths */
paths[1] = estr2str(hscpathstr);
}
/* add "$HOME/lib/hsc.prefs" to files-to-be-checked */
if (link_envfname(homepathstr, ENV_HOME, "lib", NULL))
{
/* add envval to paths */
paths[2] = estr2str(homepathstr);
}
/* try to open any prefs-file */
do
{ /* loop: */
path = paths[path_ctr]; /* get next path */
if (path)
{ /* is it the last one? */
set_estr(cfgfn, path); /* N->generate filename */
app_estr(cfgfn, CONFIG_FILE);
DC(fprintf(stderr, DHL "try \"%s\"\n", estr2str(cfgfn)));
cfgf = fopen(estr2str(cfgfn), "r"); /* try to open file */
}
path_ctr++; /* process next path */
}
while (path && (!cfgf)); /* until no path left or file opened */
if (cfgf)
{
prefs_fname = estr2str(cfgfn);
fclose(cfgf);
}
del_estr(homepathstr);
del_estr(hscpathstr);
return (prefs_fname);
}
/*
** skip_until_eot_args
**
** skip until end of tag reached,
** with user definable status vars
**
** params: inpf.....input file
** quote....status for quote (TRUE=inside quote)
** dquote...status for double quote
** argattr..status for quote
** result: TRUE, if no fatal error
** errors: return FALSE
*/
BOOL skip_until_eot_state( INFILE *inpf, BYTE *state, EXPSTR *logstr )
{
while( !eot_reached( inpf, state ) )
if ( logstr ) {
app_estr( logstr, infgetcws( inpf ) );
app_estr( logstr, infgetcw( inpf ) );
}
/* append ">" */
if ( logstr ) {
app_estr( logstr, infgetcws( inpf ) );
app_estr( logstr, infgetcw( inpf ) );
}
return( (BOOL) !fatal_error );
}
/*
* skip_until_eot_args
*
* skip until end of tag reached,
* with user definable status vars
*
* params: inpf.....input file
* quote....status for quote (TRUE=inside quote)
* dquote...status for double quote
* argattr..status for quote
* result: TRUE, if no fatal error
* errors: return FALSE
*/
static BOOL skip_until_eot_state(HSCPRC * hp, BYTE * state, EXPSTR * logstr)
{
INFILE *inpf = hp->inpf;
while (!eot_reached(hp, state))
if (logstr)
{
app_estr(logstr, infgetcws(inpf));
app_estr(logstr, infgetcw(inpf));
}
/* append ">" */
if (logstr)
{
app_estr(logstr, infgetcws(inpf));
app_estr(logstr, infgetcw(inpf));
}
return ((BOOL) ! (hp->fatal));
}
/*
** handle_hsc_exec
**
** exec a sub file
*/
BOOL handle_hsc_exec( INFILE *inpf, HSCTAG *tag )
{
STRPTR cmd = get_vartext( tag->attr, "COMMAND" );
if ( cmd ) {
int result;
EXPSTR *msg = init_estr( 0 );
if ( msg
&& app_estr( msg, "execute: " )
&& app_estr( msg, cmd ) )
{
/* status message */
status_msg( estr2str( msg ) );
if ( verbose )
status_lf();
/* call command */
result = system( cmd );
/* check for non-zero-result */
if ( result ) {
message( MSG_SYSTEM_RETURN, inpf );
errstr( "Calling external command returned " );
errstr( long2str( (LONG) result ) );
errlf();
}
} else
err_mem( inpf );
del_estr( msg );
}
return (TRUE);
}
/*
* append groups of data
*/
static VOID append_header(EXPSTR * prjstr)
{
time_t now = time(NULL); /* get current time */
/* create string for current time */
strftime(timebuf, TIMEBUFSIZE,
"%d-%b-%Y %H:%M:%S", localtime(&now));
/* append key-sequence, file-format-version and comment */
app_estr(prjstr,
FILEID_HSCPRJ "\n" LINE_VERSION_STR " ");
append_ulong(prjstr, VERSION_HSCPRJ);
app_estr(prjstr, "\n");
app_estr(prjstr,
LINE_REM_STR " Contains all data relevant for project.\n"
LINE_REM_STR " Maintained by hsc, DO NOT MODIFY!\n");
app_estr(prjstr,
LINE_REM_STR " updated: ");
app_estr(prjstr, timebuf);
app_estrch(prjstr, '\n');
}
static VOID append_caller(EXPSTR * dest, CALLER * caller)
{
#if 0
if (caller)
{
app_estr(dest, " " ID_CALLER_STR " ");
append_string(dest, caller->name);
append_ulong(dest, caller->posx);
append_ulong(dest, caller->posy);
}
#endif
}
/*
* output text function
*
* output text to host process
*
* params: hp....hsc process to perform ouput with
* wspc..white spaces
* text..other text
* result: true, if text has been outputted
*/
BOOL hsc_output_text(HSCPRC * hp, STRPTR wspc, STRPTR text) {
BOOL written = FALSE;
if ((hp)->CB_text && !((hp)->suppress_output)) {
/* add current white spaces to white space
* buffer; if hp->compact is enabled, reduce
* white spaces */
if (wspc)
app_estr(hp->whtspc, wspc);
if (hp->compact && (!hp->inside_pre))
/* reduce white spaces */
wspc = compactWs(hp, estr2str(hp->whtspc));
else
wspc = estr2str(hp->whtspc);
/* strip white spaces if requested */
if (hp->strip_next_whtspc) {
D(fprintf(stderr, DHL "bad white spaces stripped\n"));
hp->strip_next_whtspc = FALSE;
wspc = "";
} else if (hp->strip_next2_whtspc) {
hp->strip_next2_whtspc = FALSE;
hp->strip_next_whtspc = TRUE;
} else if ((hp->tag_next_whtspc) && strlen(wspc)) {
hsc_message(hp, MSG_SUCC_WHTSPC,
"succeeding white-space for %T",
hp->tag_next_whtspc);
}
hp->tag_next_whtspc = NULL;
#if DEBUG_HSCLIB_OUTPUT
if (hp->debug)
if (text)
if (strcmp(text, "\n"))
fprintf(stderr, DHL "ouput: `%s', `%s'\n", wspc, text);
else
fprintf(stderr, DHL "ouput: `%s', `\\n'\n", wspc);
#endif
if ((wspc && wspc[0]) || (text && text[0])) {
/* convert NULL values to empty strings */
if (!wspc)
wspc = "";
if (!text)
text = "";
/* output text */
(*((hp)->CB_text)) ((hp), wspc, text);
written = TRUE;
}
/* reset white space buffer */
clr_estr(hp->whtspc);
}
return (written);
}
/*
* try_set_attr
*
* if attribute exists and it's value is empty, set
* new value and update tag-attribute-string
*/
static VOID try_setattr(HSCPRC * hp, HSCVAR * attr, ULONG value)
{
if (attr)
{
STRPTR old_value = get_vartext(attr);
STRPTR new_value = long2str(value);
if (!old_value)
{
/* set new value */
set_vartext(attr, new_value);
/* append attribute name and "=" */
app_estr(hp->tag_attr_str, " ");
app_estr(hp->tag_attr_str, attr->name);
app_estr(hp->tag_attr_str, "=");
/* append quotes and value */
if ((hp->quotemode == QMODE_KEEP) || (hp->quotemode == QMODE_DOUBLE))
app_estrch(hp->tag_attr_str, '\"');
else if (hp->quotemode == QMODE_SINGLE)
app_estrch(hp->tag_attr_str, '\'');
app_estr(hp->tag_attr_str, long2str(value)); /* append value */
if ((hp->quotemode == QMODE_KEEP) || (hp->quotemode == QMODE_DOUBLE))
app_estrch(hp->tag_attr_str, '\"');
else if (hp->quotemode == QMODE_SINGLE)
app_estrch(hp->tag_attr_str, '\'');
}
else
{
/* validate old value */
if (strcmp(old_value, new_value))
{
hsc_message(hp, MSG_UNEX_ATTR_VALUE,
"unexpected value for %A: expected %q, found %q",
attr, new_value, old_value);
}
}
}
}
/* set_source_attribs */
static VOID set_source_attribs(HSCPRC * hp, STRPTR sourcepath, STRPTR sourcename)
{
app_estr(fileattr_str, "<$define HSC.SOURCE.NAME:string/c=\"");
if (sourcename)
app_estr(fileattr_str, sourcename);
app_estr(fileattr_str, "\">\n<$define HSC.SOURCE.PATH:string/c=\"");
if (sourcename)
app_estr(fileattr_str, sourcepath);
app_estr(fileattr_str, "\">\n<$define HSC.SOURCE.FILE:string/c=\"");
if (sourcename)
app_estr(fileattr_str, sourcepath);
if (sourcename)
app_estr(fileattr_str, sourcename);
app_estr(fileattr_str, "\">\n");
}
static VOID send_arexx_command(HSCPRC * hp, STRPTR arexx_command)
{
/* Hex-escaped Arexx command */
EXPSTR *escaped_arexx_command = init_estr(256);
STRPTR command_character = NULL;
BOOL insert_concatenation;
set_estr(escaped_arexx_command, "RX >nil: \"cmd='");
/* Hex-escape nasty characters in command before sending it via RX.
* Probably more characters then neccessary are escaped, but extending
* this list is faster then finding out if a character is nasty or not.
*/
command_character = arexx_command;
insert_concatenation = TRUE;
while (command_character[0] != '\0')
{
STRARR hex_buffer[10];
if (insert_concatenation)
{
app_estr(escaped_arexx_command, "'||'");
}
switch (command_character[0])
{
case '\'':
case '\"':
case '*':
case '`':
sprintf(hex_buffer, "'||'%x'x'", command_character[0]);
app_estr(escaped_arexx_command, hex_buffer);
insert_concatenation = TRUE;
break;
default:
app_estrch(escaped_arexx_command, command_character[0]);
insert_concatenation = FALSE;
break;
}
command_character += 1;
}
app_estr(escaped_arexx_command,"';");
#if DEBUG_MSGBROWSER
app_estr(escaped_arexx_command,"call open(f,'console:'); call writeln(f,cmd);");
#endif
app_estr(escaped_arexx_command,"address " SC_SCMSG " cmd");
app_estr(escaped_arexx_command, "\"");
#if DEBUG_MSGBROWSER
fprintf(stderr, "sending arexx: %s\n",
estr2str(escaped_arexx_command));
#endif
system(estr2str(escaped_arexx_command));
del_estr(escaped_arexx_command);
}
/*
* try_set_attr
*
* if attribute exists and it's value is empty, set
* new value and update tag-attribute-string
*/
static VOID try_setattr(HSCPRC * hp, HSCVAR * attr, ULONG value)
{
if (attr && !get_vartext(attr))
{
set_vartext(attr, long2str(value));
/* append attribute name and "=" */
app_estr(hp->tag_attr_str, " ");
app_estr(hp->tag_attr_str, attr->name);
app_estr(hp->tag_attr_str, "=");
/* append quotes and value */
if ((hp->quotemode == QMODE_KEEP) || (hp->quotemode == QMODE_DOUBLE))
app_estrch(hp->tag_attr_str, '\"');
else if (hp->quotemode == QMODE_SINGLE)
app_estrch(hp->tag_attr_str, '\'');
app_estr(hp->tag_attr_str, long2str(value)); /* append value */
if ((hp->quotemode == QMODE_KEEP) || (hp->quotemode == QMODE_DOUBLE))
app_estrch(hp->tag_attr_str, '\"');
else if (hp->quotemode == QMODE_SINGLE)
app_estrch(hp->tag_attr_str, '\'');
}
}
/*
* set/define_dest_attribs, define_source_attribs
*
* set and define attributes for destiantion uri
*/
static VOID set_dest_attribs(HSCPRC * hp, STRPTR destpath, STRPTR destname)
{
set_estr(fileattr_str, "<$define HSC.DOCUMENT.NAME:string/c=\"");
if (destname)
app_estr(fileattr_str, destname);
app_estr(fileattr_str, "\">\n<$define HSC.DOCUMENT.PATH:string/c=\"");
if (destname)
app_estr(fileattr_str, destpath);
app_estr(fileattr_str, "\">\n<$define HSC.DOCUMENT.URI:string/c=\"");
if (destname)
app_estr(fileattr_str, destpath);
if (destname)
app_estr(fileattr_str, destname);
app_estr(fileattr_str, "\">\n");
}
/*
* conv_uri2path
*
* convert a uri to a path for local (system-dependant)
* file system
*/
VOID conv_uri2path(EXPSTR * dest, STRPTR uri)
{
clr_estr(dest);
#ifdef AMIGA
/* convert leading "../" to "/" */
while (!strncmp(uri, PARENT_URI, strlen(PARENT_URI)))
{
app_estr(dest, PARENT_DIR);
uri += strlen(PARENT_URI);
}
/* convert inside "../" to "//" */
while (uri[0])
{
if (!strncmp(uri, PARENT_URI, strlen(PARENT_URI)))
{
app_estrch(dest, '/');
uri += strlen(PARENT_URI);
}
else
{
app_estrch(dest, uri[0]);
uri++;
}
}
#elif defined MSDOS
/* convert all "/" to "\" */
while (uri[0])
{
if (uri[0] == '/')
app_estrch(dest, '\\');
else
app_estrch(dest, uri[0]);
uri++;
}
#elif defined UNIX
set_estr(dest, uri);
#else
#error "system not supported: conv_2path"
#endif
}
/*
* hsc_parse
*
* parse input chars with full hsc support
*
* params: inpf...input file
*
* result: TRUE, if no error
*/
BOOL hsc_parse(HSCPRC * hp)
{
if (!hp->fatal)
{
STRPTR nxtwd = infgetw(hp->inpf);
STRPTR cws = infgetcws(hp->inpf); /* current WhtSpcs */
/* add white spaces to buffer */
if (cws)
{
app_estr(hp->whtspc, cws);
}
/* parse text */
if (nxtwd)
{
if (!strcmp(nxtwd, "<"))
{
/* parse tag */
hsc_parse_tag(hp);
}
else if (!strcmp(nxtwd, "&"))
{
/* parse entity */
hsc_parse_amp(hp);
}
else
{
/* handle text */
hsc_parse_text(hp);
}
}
else
{
#if 0 /* TODO: remove, this is now done in hsc_parse_end() */
/* output last white spaces at eof */
hsc_output_text(hp, "", "");
#endif
}
}
return (BOOL) (!hp->fatal);
}
