/**
* @file functions.c
*
* This module implements text functions.
*
* @addtogroup autogen
* @{
*/
/*
* This file is part of AutoGen.
* AutoGen Copyright (C) 1992-2016 by Bruce Korb - all rights reserved
*
* AutoGen is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* AutoGen is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*=macfunc CONTINUE
*
* handler-proc: Break
* load-proc: Leave
* what: Skip to end of a FOR or WHILE macro.
*
* desc:
* This will skip the remainder of the loop and start the next.
=*/
/*=macfunc BREAK
*
* handler-proc: Break
* load-proc: Leave
* what: Leave a FOR or WHILE macro
*
* desc:
* This will unwind the loop context and resume after ENDFOR/ENDWHILE.
* Note that unless this happens to be the last iteration anyway,
* the (last-for?) function will never yield "#t".
=*/
macro_t *
mFunc_Break(templ_t * tpl, macro_t * mac)
{
for_state_t * fst = curr_ivk_info->ii_for_data;
int code = (mac->md_code == FTYP_BREAK) ? LOOP_JMP_BREAK : LOOP_JMP_NEXT;
if (fst == NULL) {
char const * which =
(mac->md_code == FTYP_BREAK) ? BREAK_STR : CONTINUE_STR;
AG_ABEND(aprf(BAD_BREAK_FMT, which));
}
fst += curr_ivk_info->ii_for_depth - 1;
(void)tpl;
(void)mac;
longjmp(fst->for_env, code);
}
/**
* wrapper function for calling gen_block in a loop.
* It sets up and handles the jump buffer, returning the jump result.
*
* @param[in,out] jbuf the jump buffer
* @param[in] tpl the new active template
* @param[in] mac the looping macro
* @param[in] end_mac pointer to the first macro after the block
*
* @returns either LOOP_JMP_OKAY (0) or LOOP_JMP_BREAK (the caller should
* exit the loop).
*/
LOCAL loop_jmp_type_t
call_gen_block(jmp_buf jbuf, templ_t * tpl, macro_t * mac, macro_t * end_mac)
{
switch (setjmp(jbuf)) {
case LOOP_JMP_OKAY: // 0
gen_block(tpl, mac, end_mac);
/* FALLTHROUGH */
case LOOP_JMP_NEXT:
return LOOP_JMP_OKAY;
case LOOP_JMP_BREAK:
default:
return LOOP_JMP_BREAK;
}
}
/*=macfunc RETURN
*
* handler-proc:
* load-proc: Leave
*
* what: Leave an INVOKE-d (DEFINE) macro
*
* desc:
* This will unwind looping constructs inside of a DEFINE-d macro and
* return to the invocation point. The output files and diversions
* @i{are left alone}. This means it is unwise to start diversions
* in a DEFINEd macro and RETURN from it before you have handled the
* diversion. Unless you are careful. Here is some rope for you.
* Please be careful using it.
=*/
macro_t *
mFunc_Return(templ_t * tpl, macro_t * mac)
{
(void)tpl;
(void)mac;
free_for_context(INT_MAX);
if (curr_ivk_info->ii_prev == NULL)
AG_ABEND_IN(tpl, mac, RETURN_FROM_NOWHERE);
longjmp(curr_ivk_info->ii_env, 1);
}
/**
* Generate a block with a new template context. It may be either
* an @code{INCLUDE}-d template or a user @code{DEFINE}-d macro.
* If @code{gen_block} returns with a long jump, the long jump value
* is ignored. It was terminated early with a @code{RETURN}.
*
* @param[in] tpl new template block (included or invoked).
*/
LOCAL void
gen_new_block(templ_t * tpl)
{
templ_t * oldt = current_tpl;
ivk_info_t ii = IVK_INFO_INITIALIZER(curr_ivk_info);
curr_ivk_info = ⅈ
if (setjmp(ii.ii_env) == 0) {
macro_t * m = tpl->td_macros;
gen_block(tpl, m, m + tpl->td_mac_ct);
}
current_tpl = oldt;
curr_ivk_info = ii.ii_prev;
}
/**
* Validate the context for leaving early. @code{FOR} and @code{WHILE} loops
* may leave an interation early with @code{CONTINUE} or @code{BREAK}.
* @code{DEFINE}-d macros and @code{INCLUDE}-d files may leave early with
* @code{RETURN}. Loops may not be left early from an @code{INVOKE}-d macro
* or an @code{INCLUDE}-d template.
*
* This load function handles @code{BREAK}, @code{CONTINUE} and @code{RETURN}.
* It is always defined, so it must check for itself whether the
* context is correct or not.
*
* @param tpl template being loaded
* @param mac the macro descriptor
* @param p_scan the input text scanning pointer
*
* @returns the macro table entry after mac
*/
macro_t *
mLoad_Leave(templ_t * tpl, macro_t * mac, char const ** p_scan)
{
(void) tpl;
if (mac->md_code == FTYP_RETURN) {
/*
* Check returns at load time. "break" and "continue" at
* instantiation time.
*/
if (! defining_macro && (include_depth == 0))
(void)mLoad_Bogus(tpl, mac, p_scan);
}
return mac + 1;
}
/*=macfunc INCLUDE
*
* what: Read in and emit a template block
* handler_proc:
* load_proc: Expr
*
* desc:
*
* The entire contents of the named file is inserted at this point.
* The contents of the file are processed for macro expansion. The
* arguments are eval-ed, so you may compute the name of the file to
* be included. The included file must not contain any incomplete
* function blocks. Function blocks are template text beginning with
* any of the macro functions @samp{CASE}, @samp{DEFINE}, @samp{FOR},
* @samp{IF} and @samp{WHILE}; extending through their respective
* terminating macro functions.
=*/
macro_t *
mFunc_Include(templ_t * tpl, macro_t * mac)
{
bool allocated_name;
char const * fname = eval_mac_expr(&allocated_name);
include_depth++;
if (*fname != NUL) {
templ_t * new_tpl = tpl_load(fname, tpl->td_file);
macro_t * last_mac = new_tpl->td_macros + (new_tpl->td_mac_ct - 1);
if (last_mac->md_code == FTYP_TEXT) {
/*
* Strip off trailing white space from included templates
*/
char * pz = new_tpl->td_text + last_mac->md_txt_off;
char * pe = SPN_WHITESPACE_BACK(pz, pz);
/*
* IF there is no text left, remove the macro entirely
*/
if (pe > pz) {
*pe = NUL;
} else {
new_tpl->td_mac_ct--;
}
}
if (OPT_VALUE_TRACE > TRACE_DEBUG_MESSAGE) {
fprintf(trace_fp, TRACE_FN_INC_TPL, new_tpl->td_file);
if (OPT_VALUE_TRACE == TRACE_EVERYTHING)
fprintf(trace_fp, TRACE_FN_INC_LINE, current_tpl->td_file,
mac->md_line);
}
gen_new_block(new_tpl);
tpl_unload(new_tpl);
current_tpl = tpl;
}
include_depth--;
if (allocated_name)
AGFREE(fname);
return mac + 1;
}
/*=macfunc UNKNOWN
*
* what: Either a user macro or a value name.
* handler_proc:
* load_proc:
* unnamed:
*
* desc:
*
* The macro text has started with a name not known to AutoGen. If, at run
* time, it turns out to be the name of a defined macro, then that macro is
* invoked. If it is not, then it is a conditional expression that is
* evaluated only if the name is defined at the time the macro is invoked.
*
* You may not specify @code{UNKNOWN} explicitly.
=*/
macro_t *
mFunc_Unknown(templ_t * pT, macro_t * pMac)
{
templ_t * pInv = find_tpl(pT->td_text + pMac->md_name_off);
if (pInv != NULL) {
if (OPT_VALUE_TRACE >= TRACE_EVERYTHING)
fprintf(trace_fp, TRACE_FN_REMAPPED, TRACE_FN_REMAP_INVOKE,
pMac->md_code, pT->td_file, pMac->md_line);
pMac->md_code = FTYP_DEFINE;
pMac->md_pvt = VOIDP(pInv);
parse_mac_args(pT, pMac);
return mFunc_Define(pT, pMac);
}
if (OPT_VALUE_TRACE >= TRACE_EVERYTHING) {
fprintf(trace_fp, TRACE_FN_REMAPPED, TRACE_FN_REMAP_EXPR,
pMac->md_code, pT->td_file, pMac->md_line);
fprintf(trace_fp, TRACE_FN_REMAP_BASE,
pT->td_text + pMac->md_name_off);
}
pMac->md_code = FTYP_EXPR;
if (pMac->md_txt_off == 0) {
pMac->md_res = EMIT_VALUE;
} else {
char * pzExpr = pT->td_text + pMac->md_txt_off;
switch (*pzExpr) {
case ';':
case '(':
pMac->md_res = EMIT_EXPRESSION;
break;
case '`':
pMac->md_res = EMIT_SHELL;
span_quote(pzExpr);
break;
case '"':
case '\'':
span_quote(pzExpr);
/* FALLTHROUGH */
default:
pMac->md_res = EMIT_STRING;
}
if (OPT_VALUE_TRACE >= TRACE_EVERYTHING)
fprintf(trace_fp, TRACE_UNKNOWN_FMT, pMac->md_res, pzExpr);
}
return mFunc_Expr(pT, pMac);
}
/*=macfunc BOGUS
*
* what: Out-of-context or unknown functions are bogus.
* handler_proc:
* load_proc:
* unnamed:
=*/
macro_t *
mFunc_Bogus(templ_t * pT, macro_t * pMac)
{
char * pz = aprf(FN_BOGUS_FMT, pMac->md_code,
(pMac->md_code < FUNC_CT)
? ag_fun_names[ pMac->md_code ]
: FN_BOGUS_HUH);
AG_ABEND_IN(pT, pMac, pz);
/* NOTREACHED */
return pMac;
}
/*=macfunc TEXT
*
* what: A block of text to be emitted.
* handler_proc:
* unnamed:
=*/
macro_t *
mFunc_Text(templ_t * pT, macro_t * pMac)
{
fputs(pT->td_text + pMac->md_txt_off, cur_fpstack->stk_fp);
fflush(cur_fpstack->stk_fp);
return pMac + 1;
}
/*=macfunc COMMENT
*
* what: A block of comment to be ignored
* load_proc:
* alias: "#"
*
* desc:
* This function can be specified by the user, but there will
* never be a situation where it will be invoked at emit time.
* The macro is actually removed from the internal representation.
*
* If the native macro name code is @code{#}, then the
* entire macro function is treated as a comment and ignored.
*
* @example
* [+ # say what you want, but no '+' before any ']' chars +]
* @end example
=*/
macro_t *
mLoad_Comment(templ_t * tpl, macro_t * mac, char const ** p_scan)
{
(void)tpl;
(void)p_scan;
memset(VOIDP(mac), 0, sizeof(*mac));
return mac;
}
/**
* The default (unknown) load function.
*
* Move any text into the text offset field. This macro will change to
* either INVOKE or an expression function, depending on whether or not a
* DEFINE macro corresponds to the name. This is determined at instantiation
* time. This is used as the default load mechanism.
*
* @param tpl template being loaded
* @param mac the macro descriptor
* @param p_scan the input text scanning pointer
*
* @returns the macro table entry after mac
*/
macro_t *
mLoad_Unknown(templ_t * tpl, macro_t * mac, char const ** unused)
{
char const * scan;
ssize_t src_len = (ssize_t)mac->md_res; /* macro len */
(void)unused;
if (src_len <= 0)
goto return_emtpy_expr;
scan = (char const *)mac->md_txt_off; /* macro text */
switch (*scan) {
case ';':
{
char const * start = scan;
/*
* Strip off scheme comments
*/
do {
scan = strchr(scan, NL);
if (scan == NULL)
goto return_emtpy_expr;
scan = SPN_WHITESPACE_CHARS(scan);
if (*scan == NUL)
goto return_emtpy_expr;
src_len -= scan - start;
if (src_len <= 0)
goto return_emtpy_expr;
start = scan;
} while (*scan == ';');
break;
}
case '[':
case '.':
{
/*
* We are going to recopy the definition name, this time as a
* canonical name (i.e. including '[', ']' and '.' characters,
* but with all blanks squeezed out)
*/
char * cname = tpl->td_text + mac->md_name_off;
size_t cname_len = strlen(cname);
/*
* Move back the source pointer. We may have skipped blanks,
* so skip over however many first, then back up over the name.
* We have found a name, so we won't back up past the start.
*/
while (IS_WHITESPACE_CHAR(scan[-1])) scan--, src_len++;
scan -= cname_len;
src_len += (ssize_t)cname_len;
/*
* Now copy over the full canonical name. Check for errors.
* Advance the scan pointer to just past the name we've copied.
*/
{
ssize_t rem_len = canonical_name(cname, scan, (int)src_len);
if (rem_len > src_len)
AG_ABEND_IN(tpl, mac, LD_UNKNOWN_INVAL_DEF);
scan += src_len - rem_len;
src_len = (ssize_t)rem_len;
}
/*
* Where we are stashing text ("td_scan") gets set to just past the
* NUL byte terminating the name. "cname" is now longer than before.
*/
tpl->td_scan = cname + strlen(cname) + 1;
if (src_len <= 0)
goto return_emtpy_expr;
break;
}
}
/*
* Copy the expression (the remaining text)
*/
{
char * dest = tpl->td_scan; /* next text dest */
mac->md_txt_off = (uintptr_t)(dest - tpl->td_text);
mac->md_res = 0;
memcpy(dest, scan, (size_t)src_len);
dest += src_len;
*(dest++) = NUL;
*dest = NUL; /* double terminate */
tpl->td_scan = dest;
}
return mac + 1;
return_emtpy_expr:
mac->md_txt_off = 0;
mac->md_res = 0;
return mac + 1;
}
/**
* Some functions are known to AutoGen, but invalid out of context.
* For example, ELIF, ELSE and ENDIF are all known to AutoGen.
* However, the load function pointer for those functions points
* here, until an "IF" function is encountered.
*
* @param tpl template being loaded
* @param mac the macro descriptor
* @param p_scan the input text scanning pointer
*
* @returns the macro table entry after mac
*/
macro_t *
mLoad_Bogus(templ_t * tpl, macro_t * mac, char const ** p_scan)
{
char const * pzSrc = (char const *)mac->md_txt_off; /* macro text */
char const * pzMac;
char z[ 64 ];
(void)p_scan;
if (pzSrc != NULL) {
z[0] = ':';
z[1] = z[2] = ' ';
strncpy(z+3, pzSrc, (size_t)60);
z[63] = NUL;
pzSrc = z;
}
else
pzSrc = zNil;
{
int ix = mac->md_code;
if ((unsigned)ix >= FUNC_CT)
ix = 0;
pzMac = ag_fun_names[ ix ];
}
pzSrc = aprf(LD_BOGUS_UNKNOWN, tpl->td_file, mac->md_line, pzMac, pzSrc);
AG_ABEND_IN(tpl, mac, pzSrc);
/* NOTREACHED */
return NULL;
}
/**
* @}
*
* Local Variables:
* mode: C
* c-file-style: "stroustrup"
* indent-tabs-mode: nil
* End:
* end of agen5/functions.c */