string
get_latex_style (tree t) {
if (N(t) != 3 && N(t) != 2) return "";
string s= trim_spaces (string_arg (t[N(t)-1]));
string opt= N(t)==3? trim_spaces (string_arg (t[1])): string ("");
array<string> opts= trim_spaces (tokenize (opt, ","));
if (N(t) == 3 && occurs ("acmart", s)) {
if (occurs ("acmsmall", opt)) return "acmsmall";
}
if (N(t) == 3 && occurs ("revtex", s)) {
if (contains (string ("aip"), opts)) return "aip";
if (contains (string ("aps"), opts)) return "aps";
}
if (occurs ("llncs", s))
return "llncs";
if (occurs ("svjour", s))
return "svjour";
if (occurs ("ifacconf", s))
return "ifac";
if (occurs ("IEEEconf", s))
return "ieeeconf";
if (occurs ("IEEEtran", s))
return "ieeetran";
if (occurs ("acm_proc", s))
return "acmconf";
if (occurs ("sig-alt", s))
return "sig-alternate";
return s;
}
NODE *lremprop(NODE *args)
{
NODE *plname, *pname, *plist, *val = NIL;
BOOLEANx caseig = FALSE;
if (compare_node(valnode__caseobj(Caseignoredp), Truex, TRUE) == 0)
caseig = TRUE;
plname = string_arg(args);
pname = string_arg(cdr(args));
if (NOT_THROWING)
{
plname = intern(plname);
plist = plist__caseobj(plname);
if (plist != NIL)
{
if (compare_node(car(plist), pname, caseig) == 0)
setplist__caseobj(plname, cddr(plist));
else
{
val = getprop(plist, pname, TRUE);
if (val != NIL)
setcdr(cdr(val), cddr(cddr(val)));
}
}
}
return (UNBOUND);
}
NODE *lpprop(NODE *args)
{
NODE *plname, *pname, *newval, *plist, *val = NIL;
plname = string_arg(args);
pname = string_arg(cdr(args));
newval = car(cddr(args));
if (NOT_THROWING)
{
plname = intern(plname);
if (flag__caseobj(plname, PLIST_TRACED))
{
ndprintf(writestream, "Pprop %s %s %s", maybe_quote(plname),
maybe_quote(pname), maybe_quote(newval));
if (ufun != NIL)
ndprintf(writestream, " in %s\n%s", ufun, this_line);
new_line(writestream);
}
plist = plist__caseobj(plname);
if (plist != NIL)
val = getprop(plist, pname, FALSE);
if (val != NIL)
setcar(cdr(val), newval);
else
setplist__caseobj(plname, cons(pname, cons(newval, plist)));
}
return (UNBOUND);
}
NODE *lgprop(NODE *args)
{
NODE *plname, *pname, *plist, *val = NIL;
plname = string_arg(args);
pname = string_arg(cdr(args));
if (NOT_THROWING)
{
plname = intern(plname);
plist = plist__caseobj(plname);
if (plist != NIL)
val = getprop(plist, pname, FALSE);
if (val != NIL)
return cadr(val);
}
return NIL;
}
NODE *luppercase(NODE *args)
{
NODE *arg;
arg = string_arg(args);
if (NOT_THROWING)
{
return make_strnode(getstrptr(arg), (char *) NULL,
getstrlen(arg), nodetype(arg), cap_strnzcpy);
}
return UNBOUND;
}
static int
process_arguments(int argc, char **argv)
{
program_name = argv[0];
while (++argv, --argc != 0 && argv[0][0] == '-' && argv[0][2] == '\0') {
switch(argv[0][1]) {
case 'o':
if ((output_prefix = string_arg(&argc, &argv)) == 0)
return 0;
break;
case 'k':
if ((keywords_file = string_arg(&argc, &argv)) == 0)
return 0;
break;
default:
usage();
}
}
if (argc != 1)
usage();
input_file_name= argv[0];
return 1;
}
NODE *lplist(NODE *args)
{
NODE *plname, *plist, *val = NIL;
plname = string_arg(args);
if (NOT_THROWING)
{
plname = intern(plname);
plist = plist__caseobj(plname);
if (plist != NIL)
val = copy_list(plist);
}
return (val);
}
int python_call_function(void)
{
if( !python_is_initialised_check() )
return 0;
if( check_args( 1, 1+EmacsPythonCallCommand::MAX_ARGS ) )
return 0;
EmacsPythonCallCommand py_command;
if( !string_arg( 1 ) )
return 0;
py_command.python_function = ml_value.asString();
const int first_arg = 2;
py_command.num_args = cur_exec->p_nargs - 1;
for( int arg=first_arg; !ml_err && arg<=cur_exec->p_nargs; arg++ )
{
if( !eval_arg( arg ) )
return 0;
switch( ml_value.exp_type() )
{
case ISINTEGER:
case ISSTRING:
py_command.python_args[ arg - first_arg ] = ml_value;
break;
case ISVOID:
case ISMARKER:
case ISWINDOWS:
case ISARRAY:
error( FormatString("Python-call - unsupported expression type for arg %d") << arg );
return 0;
}
}
py_command.executeCommand();
if( py_command.failed() )
error( py_command.failureReason() );
else
ml_value = py_command.getResult();
return 0;
}
NODE *lword(NODE *args) {
NODE *val = NIL, *arg = NIL;
int cnt = 0;
NODETYPES str_type = STRING;
if (args == NIL) return Null_Word;
val = args;
while (val != NIL && NOT_THROWING) {
arg = string_arg(val);
val = cdr(val);
if (NOT_THROWING) {
if (backslashed(arg))
str_type = VBAR_STRING;
cnt += getstrlen(arg);
}
}
if (NOT_THROWING)
val = make_strnode((char *)args, (struct string_block *)NULL,
cnt, str_type, word_strnzcpy); /* kludge */
else
val = UNBOUND;
return(val);
}
static array<tree>
get_springer_author_datas (tree t, string s, bool llncs=false) {
s= "\\author-" * s;
int i, n=N(t);
bool line_break= true;
array<tree> r;
tree u;
tree author_data (APPLY, "\\author-data");
tree author_name (CONCAT);
for (i=0; i<n; i++) {
u= t[i];
if (is_tuple (u, "\\and")) {
line_break= false;
if (N(author_name) > 1) {
tree tmp= concat();
for (int j=0; j<N(author_name); j++)
if (j+1 < N(author_name) || !is_line_break (author_name[j]))
tmp << author_name[j];
if (N(tmp) > 1)
author_data << tree (APPLY, s, tmp);
author_name= tree (CONCAT);
}
if (N(author_data) > 1) {
r << author_data;
author_data= tree (APPLY, "\\author-data");
}
line_break= true;
}
else if (is_springer_titlenote (u))
author_data << tree (APPLY, "\\author-note", u[1]);
else if (llncs && is_tuple (u, "\\inst", 1))
author_data << tree (APPLY, "\\author-inst", string_arg (u[1]));
else if (is_tuple (u, "\\email", 1))
author_data << tree (APPLY, "\\author-email", u[1]);
else if (is_tuple (u, "\\tmhomepage", 1))
author_data << tree (APPLY, "\\author-homepage", u[1]);
else if (is_tuple (u, "\\tmmisc", 1))
author_data << tree (APPLY, "\\author-misc", u[1]);
else if (!line_break || !is_line_break (u)) {
if (!line_break || (u != " " && u != concat (" ") && u != concat ()))
author_name << u;
if (is_line_break (u)) line_break= true;
else if (u != " " && u != concat (" ") && u != concat ())
line_break= false;
}
}
if (N(author_name) > 1) {
tree tmp= concat();
for (int j=0; j<N(author_name); j++)
if (j+1 < N(author_name) || !is_line_break (author_name[j]))
tmp << author_name[j];
if (N(tmp) > 1)
author_data << tree (APPLY, s, tmp);
author_name= tree (CONCAT);
}
if (N(author_data) > 1) {
r << author_data;
author_data= tree (APPLY, "\\author-data");
}
return r;
}
NODE *parser_iterate(char **inln, char *inlimit, struct string_block *inhead,
BOOLEAN semi, int endchar) {
char ch, *wptr = NULL;
static char terminate = '\0'; /* KLUDGE */
NODE *outline = NIL, *lastnode = NIL, *tnode = NIL;
int windex = 0, vbar = 0;
NODETYPES this_type = STRING;
BOOLEAN broken = FALSE;
do {
/* get the current character and increase pointer */
ch = **inln;
if (!vbar && windex == 0) wptr = *inln;
if (++(*inln) >= inlimit) *inln = &terminate;
/* skip through comments and line continuations */
while (!vbar && ((semi && ch == ';') ||
#ifdef WIN32
(ch == '~' && (**inln == 012 || **inln == 015)))) {
while (ch == '~' && (**inln == 012 || **inln == 015)) {
#else
(ch == '~' && **inln == '\n'))) {
while (ch == '~' && **inln == '\n') {
#endif
if (++(*inln) >= inlimit) *inln = &terminate;
ch = **inln;
if (windex == 0) wptr = *inln;
else {
if (**inln == ']' || **inln == '[' ||
**inln == '{' || **inln == '}') {
ch = ' ';
break;
} else {
broken = TRUE;
}
}
if (++(*inln) >= inlimit) *inln = &terminate;
}
if (semi && ch == ';') {
#ifdef WIN32
if (**inln != 012 && **inln != 015)
#else
if (**inln != '\n')
#endif
do {
ch = **inln;
if (windex == 0) wptr = *inln;
else broken = TRUE;
if (++(*inln) >= inlimit) *inln = &terminate;
}
#ifdef WIN32
while (ch != '\0' && ch != '~' && **inln != 012 && **inln != 015);
#else /* !Win32 */
while (ch != '\0' && ch != '~' && **inln != '\n');
#endif
if (ch != '\0' && ch != '~') ch = '\n';
}
}
/* flag that this word will be of BACKSLASH_STRING type */
if (getparity(ch)) this_type = BACKSLASH_STRING;
if (ch == '|') {
vbar = !vbar;
this_type = VBAR_STRING;
broken = TRUE; /* so we'll copy the chars */
}
else if (vbar || (!white_space(ch) && ch != ']' &&
ch != '{' && ch != '}' && ch != '['))
windex++;
if (vbar) continue;
else if (ch == endchar) break;
else if (ch == ']') err_logo(UNEXPECTED_BRACKET, NIL);
else if (ch == '}') err_logo(UNEXPECTED_BRACE, NIL);
/* if this is a '[', parse a new list */
else if (ch == '[') {
tnode = cons(parser_iterate(inln,inlimit,inhead,semi,']'), NIL);
if (**inln == '\0') ch = '\0';
}
else if (ch == '{') {
tnode = cons(list_to_array
(parser_iterate(inln,inlimit,inhead,semi,'}')), NIL);
if (**inln == '@') {
int i = 0, sign = 1;
(*inln)++;
if (**inln == '-') {
sign = -1;
(*inln)++;
}
while ((ch = **inln) >= '0' && ch <= '9') {
i = (i*10) + ch - '0';
(*inln)++;
}
setarrorg(car(tnode),sign*i);
}
if (**inln == '\0') ch = '\0';
}
/* if this character or the next one will terminate string, make the word */
else if (white_space(ch) || **inln == ']' || **inln == '[' ||
**inln == '{' || **inln == '}') {
if (windex > 0 || this_type == VBAR_STRING) {
if (broken == FALSE)
tnode = cons(make_strnode(wptr, inhead, windex,
this_type, strnzcpy),
NIL);
else {
tnode = cons(make_strnode(wptr,
(struct string_block *)NULL, windex,
this_type, (semi ? mend_strnzcpy : mend_nosemi)),
NIL);
broken = FALSE;
}
this_type = STRING;
windex = 0;
}
}
/* put the word onto the end of the return list */
if (tnode != NIL) {
if (outline == NIL) outline = tnode;
else setcdr(lastnode, tnode);
lastnode = tnode;
tnode = NIL;
}
} while (ch);
return(outline);
}
NODE *parser(NODE *nd, BOOLEAN semi) {
NODE *rtn;
int slen;
char *lnsav;
rtn = cnv_node_to_strnode(nd);
slen = getstrlen(rtn);
lnsav = getstrptr(rtn);
rtn = parser_iterate(&lnsav,lnsav + slen,getstrhead(rtn),semi,-1);
return(rtn);
}
NODE *lparse(NODE *args) {
NODE *arg, *val = UNBOUND;
arg = string_arg(args);
if (NOT_THROWING) {
val = parser(arg, FALSE);
}
return(val);
}
std::string CommandLineArguments::GetStringCorrespondingToOption(const std::string& rOption, int valueNumber)
{
char* val = GetValueCorrespondingToOption(rOption, valueNumber);
std::string string_arg(val);
return string_arg;
}
