void Branch__functions(caStack* stack)
{
Branch* branch = as_branch(circa_input(stack, 0));
if (branch == NULL)
return circa_output_error(stack, "NULL branch");
caValue* output = circa_output(stack, 0);
set_list(output, 0);
for (BranchIteratorFlat it(branch); it.unfinished(); it.advance()) {
Term* term = *it;
if (is_function(term)) {
set_branch(list_append(output), function_contents(as_function(term)));
}
}
}
int parser_t::get_lineno() const
{
int lineno = -1;
if (! execution_contexts.empty())
{
lineno = execution_contexts.back()->get_current_line_number();
/* If we are executing a function, we have to add in its offset */
const wchar_t *function_name = is_function();
if (function_name != NULL)
{
lineno += function_get_definition_offset(function_name);
}
}
return lineno;
}
static BOOL CALLBACK
enum_functions_callback (SYMBOL_INFO * sym_info,
gulong symbol_size,
gpointer user_context)
{
GArray * result = user_context;
(void) symbol_size;
if (is_function (sym_info))
{
gpointer address = GSIZE_TO_POINTER (sym_info->Address);
g_array_append_val (result, address);
}
return TRUE;
}
Term ProcDelVertex(Term t, List ind)
{
List l, pl;
if(lagr_hash==NULL)
{
ErrorInfo(107);
puts("DelVertex: no vertices");
return 0;
}
if(!is_compound(t)||CompoundArity(t)!=1)
{
ErrorInfo(107);
puts("wrong call to DelVertex");
return 0;
}
pl=CompoundArg1(t);
if(!is_list(pl))
{
ErrorInfo(107);
puts("wrong call to DelVertex");
return 0;
}
for(l=pl;l;l=ListTail(l))
if(is_function(ListFirst(l),0))
ChangeList(l,CallFunction(ListFirst(l),0));
pl=SortedList(pl,acmp);
l=finda2(pl,1);
if(is_empty_list(l))
{
WarningInfo(108);printf("DelVertex: vertex ");
WriteTerm(pl); puts(" not found");
return 0;
}
return 0;
}
void native_patch_apply_patch(NativePatch* module, Block* block)
{
// Walk through list of patches, and try to find any functions to apply them to.
std::map<std::string, EvaluateFunc>::const_iterator it;
for (it = module->patches.begin(); it != module->patches.end(); ++it) {
std::string const& name = it->first;
EvaluateFunc evaluateFunc = it->second;
Term* term = find_local_name(block, name.c_str());
if (term == NULL)
continue;
if (!is_function(term))
continue;
install_function(term, evaluateFunc);
}
}
void list_initialize_parameter_from_type_decl(Block* typeDecl, caValue* parameter)
{
set_list(parameter, 2);
caValue* types = set_list(list_get(parameter, 0), 0);
caValue* names = set_list(list_get(parameter, 1), 0);
// Iterate through the type definition.
for (int i=0; i < typeDecl->length(); i++) {
Term* term = typeDecl->get(i);
if (!is_function(term))
continue;
Type* type = function_get_output_type(term, 0);
set_type(list_append(types), type);
set_string(list_append(names), term->name);
}
}
void write_statement(CppWriter& writer, Term* term)
{
if (is_comment(term)) {
if (term->stringProp("comment") != "") {
writer.write("//");
writer.write(term->stringProp("comment"));
}
} else if (is_function(term)) {
write_function(writer, term);
} else if (is_statement(term)) {
if (term->name != "") {
write_type_name(writer, term->type);
writer.write(" ");
writer.write(term->name);
writer.write(" = ");
}
write_expression(writer, term);
writer.write(";");
}
}
void write_term(SourceWriter* writer, Term* term)
{
if (is_comment(term)) {
if (is_empty_comment(term))
return;
writer->write("// ");
writer->write(term->stringProp("comment","").c_str());
writer->newline();
return;
}
if (is_function(term)) {
write_function(writer, term);
return;
}
writer->write(get_unique_name(term));
writer->write(" = ");
if (is_value(term)) {
write_term_value(writer, term);
} else {
// function call syntax
writer->write(term->function->name.c_str());
writer->write("(");
// write inputs
for (int i=0; i < term->numInputs(); i++) {
if (i > 0) {
writer->write(", ");
}
writer->write(get_unique_name(term));
}
}
writer->write(";");
writer->newline();
}
/*******************************************************************
* output_module16
*
* Output code for a 16-bit module.
*/
static void output_module16( DLLSPEC *spec )
{
ORDDEF **typelist;
ORDDEF *entry_point = NULL;
int i, j, nb_funcs;
/* store the main entry point as ordinal 0 */
if (!spec->ordinals)
{
assert(spec->limit == 0);
spec->ordinals = xmalloc( sizeof(spec->ordinals[0]) );
spec->ordinals[0] = NULL;
}
if (spec->init_func && !(spec->characteristics & IMAGE_FILE_DLL))
{
entry_point = xmalloc( sizeof(*entry_point) );
entry_point->type = TYPE_PASCAL;
entry_point->ordinal = 0;
entry_point->lineno = 0;
entry_point->flags = FLAG_REGISTER;
entry_point->name = NULL;
entry_point->link_name = xstrdup( spec->init_func );
entry_point->export_name = NULL;
entry_point->u.func.nb_args = 0;
assert( !spec->ordinals[0] );
spec->ordinals[0] = entry_point;
}
/* Build sorted list of all argument types, without duplicates */
typelist = xmalloc( (spec->limit + 1) * sizeof(*typelist) );
for (i = nb_funcs = 0; i <= spec->limit; i++)
{
ORDDEF *odp = spec->ordinals[i];
if (!odp) continue;
if (is_function( odp )) typelist[nb_funcs++] = odp;
}
nb_funcs = sort_func_list( typelist, nb_funcs, callfrom16_type_compare );
/* Output the module structure */
output( "\n/* module data */\n\n" );
output( "\t.data\n" );
output( "\t.align %d\n", get_alignment(4) );
output("\t.globl __wine_spec_dos_header\n");
output("__wine_spec_dos_header:\n");
output("\t.globl _wine_spec_dos_header\n");
output("_wine_spec_dos_header:\n");
output( ".L__wine_spec_dos_header:\n" );
output( "\t.short 0x5a4d\n" ); /* e_magic */
output( "\t.short 0\n" ); /* e_cblp */
output( "\t.short 0\n" ); /* e_cp */
output( "\t.short 0\n" ); /* e_crlc */
output( "\t.short 0\n" ); /* e_cparhdr */
output( "\t.short 0\n" ); /* e_minalloc */
output( "\t.short 0\n" ); /* e_maxalloc */
output( "\t.short 0\n" ); /* e_ss */
output( "\t.short 0\n" ); /* e_sp */
output( "\t.short 0\n" ); /* e_csum */
output( "\t.short 0\n" ); /* e_ip */
output( "\t.short 0\n" ); /* e_cs */
output( "\t.short 0\n" ); /* e_lfarlc */
output( "\t.short 0\n" ); /* e_ovno */
output( "\t.short 0,0,0,0\n" ); /* e_res */
output( "\t.short 0\n" ); /* e_oemid */
output( "\t.short 0\n" ); /* e_oeminfo */
output( "\t.short 0,0,0,0,0,0,0,0,0,0\n" ); /* e_res2 */
output( "\t.long .L__wine_spec_ne_header-.L__wine_spec_dos_header\n" );/* e_lfanew */
output( ".L__wine_spec_ne_header:\n" );
output( "\t.short 0x454e\n" ); /* ne_magic */
output( "\t.byte 0\n" ); /* ne_ver */
output( "\t.byte 0\n" ); /* ne_rev */
output( "\t.short .L__wine_spec_ne_enttab-.L__wine_spec_ne_header\n" );/* ne_enttab */
output( "\t.short .L__wine_spec_ne_enttab_end-.L__wine_spec_ne_enttab\n" );/* ne_cbenttab */
output( "\t.long 0\n" ); /* ne_crc */
output( "\t.short 0x%04x\n", NE_FFLAGS_SINGLEDATA | /* ne_flags */
((spec->characteristics & IMAGE_FILE_DLL) ? NE_FFLAGS_LIBMODULE : 0) );
output( "\t.short 2\n" ); /* ne_autodata */
output( "\t.short %u\n", spec->heap_size ); /* ne_heap */
output( "\t.short 0\n" ); /* ne_stack */
if (!entry_point) output( "\t.long 0\n" ); /* ne_csip */
else output( "\t.short .L__wine_%s_0-.L__wine_spec_code_segment,1\n",
make_c_identifier(spec->dll_name) );
output( "\t.short 0,2\n" ); /* ne_sssp */
output( "\t.short 2\n" ); /* ne_cseg */
output( "\t.short 0\n" ); /* ne_cmod */
output( "\t.short 0\n" ); /* ne_cbnrestab */
output( "\t.short .L__wine_spec_ne_segtab-.L__wine_spec_ne_header\n" );/* ne_segtab */
output( "\t.short .L__wine_spec_ne_rsrctab-.L__wine_spec_ne_header\n" ); /* ne_rsrctab */
output( "\t.short .L__wine_spec_ne_restab-.L__wine_spec_ne_header\n" ); /* ne_restab */
output( "\t.short .L__wine_spec_ne_modtab-.L__wine_spec_ne_header\n" ); /* ne_modtab */
output( "\t.short .L__wine_spec_ne_imptab-.L__wine_spec_ne_header\n" ); /* ne_imptab */
output( "\t.long 0\n" ); /* ne_nrestab */
output( "\t.short 0\n" ); /* ne_cmovent */
output( "\t.short 0\n" ); /* ne_align */
output( "\t.short 0\n" ); /* ne_cres */
output( "\t.byte 0x02\n" ); /* ne_exetyp = NE_OSFLAGS_WINDOWS */
output( "\t.byte 0x08\n" ); /* ne_flagsothers = NE_AFLAGS_FASTLOAD */
output( "\t.short 0\n" ); /* ne_pretthunks */
output( "\t.short 0\n" ); /* ne_psegrefbytes */
output( "\t.short 0\n" ); /* ne_swaparea */
output( "\t.short 0\n" ); /* ne_expver */
/* segment table */
output( "\n.L__wine_spec_ne_segtab:\n" );
/* code segment entry */
output( "\t.short .L__wine_spec_code_segment-.L__wine_spec_dos_header\n" ); /* filepos */
output( "\t.short .L__wine_spec_code_segment_end-.L__wine_spec_code_segment\n" ); /* size */
output( "\t.short 0x2000\n" ); /* flags = NE_SEGFLAGS_32BIT */
output( "\t.short .L__wine_spec_code_segment_end-.L__wine_spec_code_segment\n" ); /* minsize */
/* data segment entry */
output( "\t.short .L__wine_spec_data_segment-.L__wine_spec_dos_header\n" ); /* filepos */
output( "\t.short .L__wine_spec_data_segment_end-.L__wine_spec_data_segment\n" ); /* size */
output( "\t.short 0x0001\n" ); /* flags = NE_SEGFLAGS_DATA */
output( "\t.short .L__wine_spec_data_segment_end-.L__wine_spec_data_segment\n" ); /* minsize */
/* resource directory */
output_res16_directory( spec );
/* resident names table */
output( "\n\t.align %d\n", get_alignment(2) );
output( ".L__wine_spec_ne_restab:\n" );
output_resident_name( spec->dll_name, 0 );
for (i = 1; i <= spec->limit; i++)
{
ORDDEF *odp = spec->ordinals[i];
if (!odp || !odp->name[0]) continue;
if (odp->flags & FLAG_EXPORT32) continue;
output_resident_name( odp->name, i );
}
output( "\t.byte 0\n" );
/* imported names table */
output( "\n\t.align %d\n", get_alignment(2) );
output( ".L__wine_spec_ne_modtab:\n" );
output( ".L__wine_spec_ne_imptab:\n" );
output( "\t.byte 0,0\n" );
/* entry table */
output( "\n.L__wine_spec_ne_enttab:\n" );
output_entry_table( spec );
output( ".L__wine_spec_ne_enttab_end:\n" );
/* code segment */
output( "\n\t.align %d\n", get_alignment(2) );
output( ".L__wine_spec_code_segment:\n" );
for ( i = 0; i < nb_funcs; i++ )
{
unsigned int arg_types[2];
int nop_words, pos, argsize = 0;
if ( typelist[i]->type == TYPE_PASCAL )
argsize = get_function_argsize( typelist[i] );
/* build the arg types bit fields */
arg_types[0] = arg_types[1] = 0;
for (j = pos = 0; j < typelist[i]->u.func.nb_args && pos < 20; j++, pos++)
{
int type = 0;
switch (typelist[i]->u.func.args[j])
{
case ARG_WORD: type = ARG16_WORD; break;
case ARG_SWORD: type = ARG16_SWORD; break;
case ARG_SEGPTR: type = ARG16_LONG; break;
case ARG_SEGSTR: type = ARG16_SEGSTR; break;
case ARG_LONG: type = ARG16_LONG; break;
case ARG_PTR: type = ARG16_PTR; break;
case ARG_STR: type = ARG16_STR; break;
case ARG_WSTR: type = ARG16_PTR; break;
case ARG_FLOAT: type = ARG16_LONG; break;
case ARG_INT128: type = ARG16_PTR; break;
case ARG_INT64:
case ARG_DOUBLE:
type = ARG16_LONG;
arg_types[pos / 10] |= type << (3 * (pos % 10));
pos++;
break;
}
if (pos < 20) arg_types[pos / 10] |= type << (3 * (pos % 10));
}
if (typelist[i]->type == TYPE_VARARGS && pos < 20)
arg_types[pos / 10] |= ARG16_VARARG << (3 * (pos % 10));
output( ".L__wine_spec_callfrom16_%s:\n", get_callfrom16_name(typelist[i]) );
output( "\tpushl $.L__wine_spec_call16_%s\n", get_relay_name(typelist[i]) );
output( "\tlcall $0,$0\n" );
if (typelist[i]->flags & FLAG_REGISTER)
{
nop_words = 4;
}
else if (typelist[i]->flags & FLAG_RET16)
{
output( "\torw %%ax,%%ax\n" );
output( "\tnop\n" ); /* so that the lretw is aligned */
nop_words = 2;
}
else
{
output( "\tshld $16,%%eax,%%edx\n" );
output( "\torl %%eax,%%eax\n" );
nop_words = 1;
}
if (argsize)
{
output( "\tlretw $%u\n", argsize );
nop_words--;
}
else output( "\tlretw\n" );
if (nop_words) output( "\t%s\n", nop_sequence[nop_words-1] );
/* the movl is here so that the code contains only valid instructions, */
/* it's never actually executed, we only care about the arg_types[] values */
output( "\t.short 0x86c7\n" );
output( "\t.long 0x%08x,0x%08x\n", arg_types[0], arg_types[1] );
}
for (i = 0; i <= spec->limit; i++)
{
ORDDEF *odp = spec->ordinals[i];
if (!odp || !is_function( odp )) continue;
output( ".L__wine_%s_%u:\n", make_c_identifier(spec->dll_name), i );
output( "\tpushw %%bp\n" );
output( "\tpushl $%s\n",
asm_name_stdcall16( odp->type == TYPE_STUB ? get_stub_name( odp, spec ) : odp->link_name , odp));
output( "\tcallw .L__wine_spec_callfrom16_%s\n", get_callfrom16_name( odp ) );
}
output( ".L__wine_spec_code_segment_end:\n" );
/* data segment */
output( "\n.L__wine_spec_data_segment:\n" );
output( "\t.byte 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0\n" ); /* instance data */
for (i = 0; i <= spec->limit; i++)
{
ORDDEF *odp = spec->ordinals[i];
if (!odp || odp->type != TYPE_VARIABLE) continue;
output( ".L__wine_%s_%u:\n", make_c_identifier(spec->dll_name), i );
output( "\t.long " );
for (j = 0; j < odp->u.var.n_values-1; j++)
output( "0x%08x,", odp->u.var.values[j] );
output( "0x%08x\n", odp->u.var.values[j] );
}
output( ".L__wine_spec_data_segment_end:\n" );
/* resource data */
if (spec->nb_resources)
{
output( "\n.L__wine_spec_resource_data:\n" );
output_res16_data( spec );
}
output( "\t.byte 0\n" ); /* make sure the last symbol points to something */
/* relay functions */
nb_funcs = sort_func_list( typelist, nb_funcs, relay_type_compare );
if (nb_funcs)
{
output( "\n/* relay functions */\n\n" );
output( "\t.text\n" );
for ( i = 0; i < nb_funcs; i++ ) output_call16_function( typelist[i] );
output( "\t.data\n" );
output( "wine_ldt_copy_ptr:\n" );
output( "\t.long %s\n", asm_name("_imp__wine_ldt_copy") );
}
free( typelist );
}
gboolean
ifnet_init (gchar * config_file)
{
GIOChannel *channel = NULL;
gchar *line;
/* Handle multiple lines with brackets */
gboolean complete = TRUE;
gboolean openrc_style = TRUE;
/* line buffer */
GString *buf;
net_parser_data_changed = FALSE;
conn_table = g_hash_table_new (g_str_hash, g_str_equal);
global_settings_table = g_hash_table_new (g_str_hash, g_str_equal);
functions_list = NULL;
if (g_file_test (config_file, G_FILE_TEST_IS_REGULAR))
channel = g_io_channel_new_file (config_file, "r", NULL);
if (channel == NULL) {
nm_log_warn (LOGD_SETTINGS, "Can't open %s", config_file);
return FALSE;
}
buf = g_string_new (NULL);
while (g_io_channel_read_line
(channel, &line, NULL, NULL, NULL) != G_IO_STATUS_EOF) {
g_strstrip (line);
/* convert multiple lines to a complete line and
* pass it to init_block_by_line() */
if (is_function (line)) {
strip_function (channel, line);
continue;
}
// New openrc style, bash arrays are not allowed. We only care about '"'
if (openrc_style && line[0] != '#' && line[0] != '\0'
&& !strchr (line, '(') && !strchr (line, ')')) {
gchar *tmp = line;
while ((tmp = strchr (tmp, '"')) != NULL) {
complete = !complete;
++tmp;
}
append_line (buf, line);
// Add "(separator) for routes. It will be easier for later parsing
if (strstr (buf->str, "via"))
g_string_append_printf (buf, "\"");
if (!complete)
continue;
strip_string (buf->str, '"');
init_block_by_line (buf->str);
g_string_free (buf, TRUE);
buf = g_string_new (NULL);
}
// Old bash arrays for baselayout-1, to be deleted
else if (line[0] != '#' && line[0] != '\0') {
if (!complete) {
complete =
g_strrstr (line,
")") == NULL ? FALSE : TRUE;
append_line (buf, line);
if (!complete) {
openrc_style = FALSE;
continue;
}
else {
openrc_style = TRUE;
}
} else {
complete =
(g_strrstr (line, "(") != NULL
&& g_strrstr (line, ")") != NULL)
|| g_strrstr (line, "(") == NULL;
append_line (buf, line);
if (!complete)
{
openrc_style = FALSE;
continue;
} else {
openrc_style = TRUE;
}
}
init_block_by_line (buf->str);
g_string_free (buf, TRUE);
buf = g_string_new (NULL);
} else
/* Blank line or comment line */
g_free (line);
}
g_string_free (buf, TRUE);
g_io_channel_shutdown (channel, FALSE, NULL);
g_io_channel_unref (channel);
return TRUE;
}
Term ExpandTerm(Term t)
{
List il=0;
Term res;
/*puts("");
WriteTerm(t);
puts("\n");*/
if(is_compound(t) && (CompoundName(t)==OPR_USCORE || CompoundName(t)==OPR_CARET))
{
t=SplitIndices(t,&il);
if(t==0)
longjmp(alg1_jmp_buf,1);
}
if(is_function(t,NULL))
return ExpandTerm(CallFunction(t,il));
if(is_float(t))
{
ErrorInfo(303);
printf(" illegal use of floating point number %f.\n",FloatValue(t));
FreeAtomic(t);
longjmp(alg1_jmp_buf,1);
}
if(is_integer(t))
{
if(IntegerValue(t)==0)
return 0;
if(il)
{
ErrorInfo(304);
puts("Integer can't have indices.\n");
longjmp(alg1_jmp_buf,1);
}
res=MakeCompound(A_MTERM,4);
SetCompoundArg(res,1,t);
SetCompoundArg(res,2,NewInteger(1));
return AppendFirst(0,res);
}
if(t==A_I)
{
res=MakeCompound(A_MTERM,4);
SetCompoundArg(res,1,NewInteger(1));
SetCompoundArg(res,2,NewInteger(-1));
return AppendFirst(0,res);
}
if(is_atom(t) || (is_compound(t) && CompoundName(t)==A_FBRACET) ||
(is_compound(t) && CompoundName(t)==A_ALG1 && CompoundArity(t)==2) ||
(is_compound(t) && (CompoundName(t)==A_SIN || CompoundName(t)==A_COS)
&& CompoundArity(t)<3 && is_integer(CompoundArg1(t))))
return AtomicTo1(t,il);
if(!is_empty_list(il))
{
ErrorInfo(307);
printf(" bad indices ");
WriteTerm(il);
printf(" in expression.\n");
longjmp(alg1_jmp_buf,1);
}
if(opSetGpm && is_compound(t) && CompoundArity(t)==2 && CompoundArg1(t)==NewInteger(1)
&& is_atom(CompoundArg2(t))
&& (CompoundArg2(t)==A_GAMMA5 || GetAtomProperty(CompoundArg2(t),A_GAMMA5))
&& (CompoundName(t)==OPR_PLUS || CompoundName(t)==OPR_MINUS))
{
Term ret,sp;
ret=MakeCompound(A_MTERM,4);
SetCompoundArg(ret,1,NewInteger(2));
SetCompoundArg(ret,2,NewInteger(1));
sp=MakeCompound(OPR_SPECIAL,2);
if(CompoundName(t)==OPR_PLUS)
SetCompoundArg(sp,2,A_GAMMAP);
else
SetCompoundArg(sp,2,A_GAMMAM);
SetCompoundArg(sp,1,CopyTerm(GetAtomProperty(A_GAMMA5,PROP_INDEX)));
SetCompoundArg(ret,3,AppendLast(NewList(),sp));
return AppendLast(NewList(),ret);
}
if(is_compound(t) && CompoundName(t)==OPR_PLUS && CompoundArity(t)==2)
{
Term t1,t2;
t1=ConsumeCompoundArg(t,1);
t2=ConsumeCompoundArg(t,2);
FreeAtomic(t);
t1=ExpandTerm(t1);
t2=ExpandTerm(t2);
return ConcatList(t1,t2);
}
if(is_compound(t) && CompoundName(t)==OPR_MINUS && CompoundArity(t)==2)
{
Term t1,t2;
t1=ConsumeCompoundArg(t,1);
t2=ConsumeCompoundArg(t,2);
FreeAtomic(t);
t1=ExpandTerm(t1);
t2=ExpandTerm(t2);
mult_no(t2,-1);
return ConcatList(t1,t2);
}
if(is_compound(t) && CompoundName(t)==OPR_MINUS && CompoundArity(t)==1)
{
Term t1;
t1=ConsumeCompoundArg(t,1);
FreeAtomic(t);
t1=ExpandTerm(t1);
mult_no(t1,-1);
return t1;
}
if(is_compound(t) && CompoundName(t)==OPR_MLT && CompoundArity(t)==2)
{
Term t1,t2;
t1=ConsumeCompoundArg(t,1);
t2=ConsumeCompoundArg(t,2);
FreeAtomic(t);
t1=ExpandTerm(t1);
t2=ExpandTerm(t2);
return multiply_l(t1,t2);
}
if(is_compound(t) && CompoundName(t)==OPR_DIV && CompoundArity(t)==2)
{
Term t1,t2,t2s;
t1=ConsumeCompoundArg(t,1);
t2=ConsumeCompoundArg(t,2);
FreeAtomic(t);
t1=ExpandTerm(t1);
t2s=CopyTerm(t2);
t2=ExpandTerm(t2);
if(ListLength(t2)!=1)
{
ErrorInfo(306);
printf(" cannot divide by \'");
WriteTerm(t2s); printf("\'.\n");
FreeAtomic(t1); FreeAtomic(t2); FreeAtomic(t2s);
longjmp(alg1_jmp_buf,1);
}
FreeAtomic(t2s);
invert_term(ListFirst(t2));
return multiply_l(t1,t2);
}
if(is_compound(t) && CompoundName(t)==OPR_POW && CompoundArity(t)==2)
{
Term t1,t2,ret;
int i,pp;
t1=ConsumeCompoundArg(t,1);
t2=ConsumeCompoundArg(t,2);
FreeAtomic(t);
if(!is_integer(t2) || IntegerValue(t2)<1)
{
ErrorInfo(307);
printf(" illegal power \'");
WriteTerm(t2); printf("\'.\n");
FreeAtomic(t1); FreeAtomic(t2);
longjmp(alg1_jmp_buf,1);
}
pp=IntegerValue(t2);
t1=ExpandTerm(t1);
ret=CopyTerm(t1);
for(i=2;i<=pp;i++)
{
Term tmp;
tmp=CopyTerm(t1);
ret=multiply_l(ret,tmp);
}
FreeAtomic(t1);
return ret;
}
ErrorInfo(309);
printf("bad expression ");
WriteTerm(t);
puts("");
longjmp(alg1_jmp_buf,1);
}
Value*
mouse_track_cf(Value** arg_list, int count)
{
// mouseTrack [on:node|#any] [prompt:"msg"] [snap:#2D|#3D] [trackCallback:fn|#(fn,arg)]
// set up value local array to hold mouse tracker command mode Value*'s
Value** vavl;
value_local_array(vavl, sizeof(tmvl) / sizeof(Value*));
tmvl* vl = (tmvl*)vavl;
// show any prompt
Value* pv = key_arg(prompt);
const TCHAR* prompt = NULL;
if (pv != &unsupplied)
{
prompt = pv->to_string();
mprintf(_T("%s "), prompt);
mflush();
}
// setup snap
Value* sv = key_arg_or_default(snap, n_2D);
if (sv != n_2D && sv != n_3D)
throw RuntimeError (MaxSDK::GetResourceStringAsMSTR(IDS_BAD_SNAP_MODE), sv);
// setup track callback fn
Value* tcb = NULL;
Value* tcbarg = NULL;
Value *tcbv = key_arg(trackCallback);
if (tcbv != &unsupplied)
{
if (is_array(tcbv)) // an array, #(fn, arg), dig out fn & arg
{
Array* tcba = (Array*)tcbv;
if (tcba->size != 2)
throw RuntimeError (MaxSDK::GetResourceStringAsMSTR(IDS_BAD_MOVE_CALLBACK_ARGS), tcbv);
tcb = tcba->data[0];
if (!is_function(tcb))
throw RuntimeError (MaxSDK::GetResourceStringAsMSTR(IDS_BAD_MOVE_CALLBACK_ARGS), tcb);
tcbarg = tcba->data[1];
}
else // just the fn
{
tcb = tcbv;
if (!is_function(tcb))
throw RuntimeError (MaxSDK::GetResourceStringAsMSTR(IDS_BAD_MOVE_CALLBACK_ARGS), tcbv);
}
}
// pickup any node to track on
vl->node_val = key_arg(on);
NodeTab& nodeTab = theTrackMouseCommandMode.proc.nodeTab;
nodeTab.SetCount(0);
if( vl->node_val->_is_collection() ) { //Multiple nodes specified
Value* args[2] = { NULL, (Value*)&nodeTab };
node_map m = { NULL, collect_nodes, args, 2 };
vl->node_val->map(m);
}
else if( vl->node_val != &unsupplied ) { //Single node specified
INode* node = vl->node_val->to_node();
nodeTab.Append( 1, &node );
}
for( int i=(nodeTab.Count()-1); i>=0; i--)
if( nodeTab[i]==NULL ) nodeTab.Delete(i,1); //Delete null nodes
// set up pickpoint options, enter trackmouse command mode & wait for it to signal completion
end_track_mouse = FALSE;
theTrackMouseCommandMode.proc.vl = vl;
theTrackMouseCommandMode.proc.snap_mode = sv;
theTrackMouseCommandMode.proc.track_callback = tcb;
theTrackMouseCommandMode.proc.track_callback_arg = tcbarg;
theTrackMouseCommandMode.proc.start_track();
//Changed from Set to Push to prevent an exception when the maxscript code changes the command mode
//Similar to fix done to MouseTool.cpp - line 661
MAXScript_interface->PushCommandMode(&theTrackMouseCommandMode);
// process windows messages until point picked or canceled or keyboard message
MSG wmsg;
while (GetMessage(&wmsg, NULL, 0,0))
{
if (wmsg.message == WM_KEYUP && (TCHAR)wmsg.wParam == VK_ESCAPE)
end_track_mouse = TRUE;
else if (wmsg.message == WM_KEYUP || wmsg.message == WM_KEYDOWN)
continue;
else if (wmsg.message != WM_RBUTTONUP) // ignore rmousebuttonup's - they mess focus
MAXScript_interface->TranslateAndDispatchMAXMessage(wmsg);
if (end_track_mouse)
break;
}
if (!end_track_mouse)
{
// we came out of message loop because of a quit, repost the quit and throw a SignalException
theTrackMouseCommandMode.proc.end_track();
MAXScript_interface->DeleteMode(&theTrackMouseCommandMode);
throw SignalException();
}
// pickup result value & dismiss input modes
theTrackMouseCommandMode.proc.end_track();
MAXScript_interface->DeleteMode(&theTrackMouseCommandMode);
Value* result = vl->result;
pop_value_local_array(vavl);
return_protected(result);
}
static void
fetch_symtab(Elf *elf, char *filename, mod_info_t *module)
{
Elf_Scn *scn = NULL, *sym = NULL;
GElf_Word strndx = 0;
size_t i, nsyms, nfuncs;
Elf_Data *symdata;
nltype *nl, *npe;
while ((scn = elf_nextscn(elf, scn)) != NULL) {
GElf_Shdr shdr;
if (gelf_getshdr(scn, &shdr) == NULL)
continue;
if (shdr.sh_type == SHT_SYMTAB ||
shdr.sh_type == SHT_DYNSYM) {
GElf_Xword chk = shdr.sh_size / shdr.sh_entsize;
nsyms = (size_t)(shdr.sh_size / shdr.sh_entsize);
if (chk != (GElf_Xword) nsyms) {
(void) fprintf(stderr, "%s: can't handle"
"more than 2^32 symbols", cmdname);
exit(ERR_INPUT);
}
strndx = shdr.sh_link;
sym = scn;
}
/*
* If we've found a real symbol table, we're done.
*/
if (shdr.sh_type == SHT_SYMTAB)
break;
}
if (sym == NULL || strndx == 0) {
(void) fprintf(stderr, "%s: missing symbol table in %s\n",
cmdname, filename);
exit(ERR_ELF);
}
if ((symdata = elf_getdata(scn, NULL)) == NULL) {
(void) fprintf(stderr, "%s: can't read symbol data from %s\n",
cmdname, filename);
exit(ERR_ELF);
}
if ((npe = nl = (nltype *) calloc(nsyms, sizeof (nltype))) == NULL) {
(void) fprintf(stderr, "%s: can't alloc %x bytes for symbols\n",
cmdname, nsyms * sizeof (nltype));
exit(ERR_ELF);
}
/*
* Now we need to cruise through the symbol table eliminating
* all non-functions from consideration, and making strings
* real.
*/
nfuncs = 0;
for (i = 1; i < nsyms; i++) {
GElf_Sym gsym;
char *name;
(void) gelf_getsym(symdata, i, &gsym);
name = elf_strptr(elf, strndx, gsym.st_name);
/*
* We're interested in this symbol if it's a function
*/
if (is_function(elf, &gsym)) {
npe->name = name;
npe->value = gsym.st_value;
npe->size = gsym.st_size;
npe->info = gsym.st_info;
npe++;
nfuncs++;
}
if (strcmp(name, PRF_END) == 0)
module->data_end = gsym.st_value;
}
if (npe == nl) {
(void) fprintf(stderr, "%s: no valid functions in %s\n",
cmdname, filename);
exit(ERR_INPUT);
}
/*
* And finally, sort the symbols by increasing address
* and remove the duplicates.
*/
qsort(nl, nfuncs, sizeof (nltype), cmp_by_address);
rm_dups(nl, &nfuncs);
module->nl = nl;
module->nfuncs = nfuncs;
}
Term ProcChVertex(Term t, List ind)
{
List l, pl, ml;
Term rpl;
Atom a1, a2;
int pli;
int ii;
if(lagr_hash==NULL)
{
ErrorInfo(107);
puts("ChVertex: no vertices");
return 0;
}
if(!is_compound(t)||CompoundArity(t)!=2)
{
ErrorInfo(107);
puts("wrong call to ChVertex");
return 0;
}
pl=CompoundArg1(t);
for(l=pl;l;l=ListTail(l))
if(is_function(ListFirst(l),0))
ChangeList(l,CallFunction(ListFirst(l),0));
rpl=CompoundArg2(t);
if(!is_list(pl)|| !is_compound(rpl) || CompoundArity(rpl)!=2)
{
ErrorInfo(107);
puts("wrong call to ChVertex");
return 0;
}
a1=CompoundArg1(rpl);a2=CompoundArg2(rpl);
if(!is_parameter(a1)||!is_parameter(a2))
{
ErrorInfo(107);
puts("wrong call to ChVertex");
return 0;
}
pl=SortedList(pl,acmp);
l=finda2(pl,0);
if(is_empty_list(l))
{
WarningInfo(108);printf("ChVertex: vertex ");
WriteTerm(pl); puts(" not found");
return 0;
}
ml=CompoundArgN(ListFirst(l),5);
ii=0;
for(l=ml;l;l=ListTail(l))
{
List l1;
for(l1=CompoundArg2(ListFirst(l));l1;l1=ListTail(l1))
if(CompoundArg1(ListFirst(l1))==a1)
{
SetCompoundArg(ListFirst(l1),1,a2);ii++;
}
}
if(ii==0)
{
WarningInfo(107);printf("ChVertex: vertex ");WriteTerm(pl);
printf("has no '%s' within.\n",AtomValue(a1));
}
return 0;
}
bool is_function(Term* term)
{
if (term == NULL)
return false;
return is_value(term) && is_function(&term->value);
}
static const char *
process_scope(PyObject *out, const char *start, const char *buff,
const char *end,
PyObject *var_matcher, PyObject *func_matcher,
const char endchar, PyObject *envvar_callback)
{
const char *p = NULL;
const char *window_start = NULL, *window_end = NULL;
const char *new_p = NULL;
const char *com_start = NULL;
char *s = NULL;
char *e = NULL;
char *temp_string = NULL;
regmatch_t matches[3];
p = buff;
matches[0].rm_so = matches[1].rm_so = matches[2].rm_so = -1;
window_start = buff;
window_end = NULL;
while (p < end && *p != endchar) {
/* wander forward to the next non space */
if (window_end != NULL) {
if (out) {
PyObject *string = PyString_FromStringAndSize(
window_start, window_end - window_start);
if (!string)
return NULL;
PyObject *result = PyObject_CallMethodObjArgs(
out, write_str, string, NULL);
Py_DECREF(string);
if (!result)
return NULL;
Py_DECREF(result);
}
window_start = p;
window_end = NULL;
}
com_start = p;
if (isspace(*p)) {
++p;
continue;
}
/* ignore comments */
if (*p == '#') {
p = walk_statement_pound(start, p, endchar);
continue;
}
if(NULL != (new_p = is_function(p, &s, &e))) {
if(-1 == asprintf(&temp_string, "%.*s", (int)(e - s), s))
return NULL;
INFO("matched func name '%s'", temp_string);
/* output it if it doesn't match */
new_p = process_scope(
NULL, start, new_p, end, NULL, NULL, '}', NULL);
INFO("ended processing '%s'", temp_string);
if (func_matcher) {
int regex_result = regex_matches(func_matcher, temp_string);
if (-1 == regex_result) {
free(temp_string);
return NULL;
}
if (regex_result) {
/* well, it matched. so it gets skipped. */
INFO("filtering func '%s'", temp_string);
window_end = com_start;
}
}
free(temp_string);
if(!new_p)
return NULL;
p = new_p;
++p;
continue;
}
// check for env assignment
if (NULL == (new_p = is_envvar(p, &s, &e))) {
//exactly as it sounds, non env assignment.
p = walk_command_complex(start, p, end,
endchar, COMMAND_PARSING);
if (!p)
return NULL;
// icky icky icky icky
if (p < end && *p != endchar)
++p;
} else {
//env assignment
if(-1 == asprintf(&temp_string, "%.*s", (int)(e - s), s))
return NULL;
INFO("matched env assign '%s'", temp_string);
do_envvar_callback(envvar_callback, temp_string);
if (var_matcher) {
int regex_result = regex_matches(var_matcher, temp_string);
if (-1 == regex_result) {
free(temp_string);
return NULL;
}
if (regex_result) {
//this would be filtered.
INFO("filtering var '%s'", temp_string);
window_end = com_start;
}
}
free(temp_string);
p = new_p;
if (p >= end) {
return p;
}
while(p < end && !isspace(*p) && ';' != *p) {
if ('\'' == *p)
p = walk_statement_no_parsing(p + 1, end, '\'') + 1;
else if ('"' == *p || '`' == *p)
p = walk_command_escaped_parsing(start, p + 1, end,
*p) + 1;
else if ('(' == *p) {
p = walk_command_escaped_parsing(start, p + 1, end,
')') + 1;
} else if ('$' == *p) {
++p;
if (p >= end) {
continue;
}
p = walk_dollar_expansion(start, p, end, endchar,
endchar);
continue;
} else {
// blah=cah ; single word.
p = walk_command_complex(start, p, end, ' ',
SPACE_PARSING);
if (!p) {
return NULL;
}
}
}
}
}
if (out) {
if (window_end == NULL)
window_end = p;
if (window_end > end)
window_end = end;
PyObject *string = PyString_FromStringAndSize(
window_start, window_end - window_start);
if (!string)
return NULL;
PyObject *result = PyObject_CallMethodObjArgs(
out, write_str, string, NULL);
Py_DECREF(string);
if (!result)
return NULL;
Py_DECREF(result);
}
return p;
}
void ProcessTerm(Term t)
{
Term res;
Atom procc=0;
char regbuf[80];
if(is_compound(t)&&CompoundName(t)==OPR_LOCAL)
{
List l1,la=ConsumeCompoundArg(t,1);
if(l_pro==0)
{
ErrorInfo(0);
puts("local: must be within template.");
return;
}
la=CommaToList(la);
for(l1=la;l1;l1=ListTail(l1))
l_ali=AppendLast(l_ali,
InterfSetAlias(MakeCompound1(OPR_ALIAS,ListFirst(l1)),0));
RemoveList(la);
return;
}
/* if(is_compound(t) && GetAtomProperty(CompoundName(t),OPR_ALIAS))
{*/
if(!is_compound(t) || (CompoundName(t)!=OPR_ALIAS &&
CompoundName(t)!=OPR_IN && CompoundName(t)!=OPR_WHERE) )
{
t=ProcessAlias(t);
proc_hash(t);
}
/*WriteTerm(t);puts("");*/
/*}*/
if(is_list(t))
{
List l, alisav;
l_pro++;
alisav=l_ali;
l_ali=0;
for(l=t;l;l=ListTail(l))
ProcessTerm(ListFirst(l));
if(l_ali)
RemoveAlias(l_ali);
RemoveList(t);
l_pro--;
l_ali=alisav;
return;
}
if(is_atom(t))
procc=t;
if(is_compound(t))
{
procc=CompoundName(t);
}
if(procc==0)
{
if(!IsTermInput())
printf("File \"%s\", line %d: ",CurrentInputFile(),
CurrentInputLine());
printf("Not a valid operator \'");
WriteTerm(t);
printf("\'.\n");
FreeAtomic(t);
return;
}
if(!IsTermInput())
sprintf(regbuf, "ProcTerm: File %s, line %d: %s statement.",
CurrentInputFile(), CurrentInputLine(), AtomValue(procc));
else
sprintf(regbuf, "(tty): %s statement.",AtomValue(procc));
RegisterLine(regbuf);
if(!is_function(t,NULL))
{
if(!IsTermInput())
printf("File \"%s\", line %d: ",CurrentInputFile(),
CurrentInputLine());
printf("Unknown operator \'%s\' in expression\n\t",AtomValue(procc));
WriteTerm(t);
puts("");
FreeAtomic(t);
UnregisterLine();
return;
}
if(is_compound(t) && ((VerbMode && CompoundName(t)==OPR_LTERM) ||
VerbMode==3))
{
char sment[1024];
sWriteTerm(sment,t);
sment[55]='.';
sment[56]='.';
sment[57]='.';
sment[58]=0;
printf("%s:%3d: %s\n",CurrentInputFile(),CurrentInputLine(),sment);
}
res=CallFunction(t,0);
if(res!=0 && (IsTermInput()))
{
if(is_compound(res) && CompoundArity(t)==2 &&
CompoundName(res)==A_ALG1)
res=Alg1ToExpr(res);
if(is_list(res))
DumpList(res);
else
{
WriteTerm(res);
puts("");
}
FreeAtomic(res);
}
UnregisterLine();
}
/* Cover both external declarations, functions, and local declarations (with
* optional initialization code) inside functions.
*/
struct block *declaration(struct block *parent)
{
struct typetree *base;
enum symtype symtype;
enum linkage linkage;
int stc = '$';
base = declaration_specifiers(&stc);
switch (stc) {
case EXTERN:
symtype = SYM_DECLARATION;
linkage = LINK_EXTERN;
break;
case STATIC:
symtype = SYM_TENTATIVE;
linkage = LINK_INTERN;
break;
case TYPEDEF:
symtype = SYM_TYPEDEF;
linkage = LINK_NONE;
break;
default:
if (!ns_ident.current_depth) {
symtype = SYM_TENTATIVE;
linkage = LINK_EXTERN;
} else {
symtype = SYM_DEFINITION;
linkage = LINK_NONE;
}
break;
}
while (1) {
struct definition *def;
const char *name = NULL;
const struct typetree *type;
struct symbol *sym;
type = declarator(base, &name);
if (!name) {
consume(';');
return parent;
}
sym = sym_add(&ns_ident, name, type, symtype, linkage);
if (ns_ident.current_depth) {
assert(ns_ident.current_depth > 1);
def = current_func();
def->locals = sym_list_add(def->locals, sym);
}
switch (peek().token) {
case ';':
consume(';');
return parent;
case '=':
if (sym->symtype == SYM_DECLARATION) {
error("Extern symbol '%s' cannot be initialized.", sym->name);
exit(1);
}
if (!sym->depth && sym->symtype == SYM_DEFINITION) {
error("Symbol '%s' was already defined.", sym->name);
exit(1);
}
consume('=');
sym->symtype = SYM_DEFINITION;
if (sym->linkage == LINK_NONE) {
assert(parent);
parent = initializer(parent, var_direct(sym));
} else {
assert(sym->depth || !parent);
def = push_back_definition(sym);
initializer(def->body, var_direct(sym));
}
assert(size_of(&sym->type) > 0);
if (peek().token != ',') {
consume(';');
return parent;
}
break;
case '{': {
int i;
if (!is_function(&sym->type) || sym->depth) {
error("Invalid function definition.");
exit(1);
}
assert(!parent);
assert(sym->linkage != LINK_NONE);
sym->symtype = SYM_DEFINITION;
def = push_back_definition(sym);
push_scope(&ns_ident);
define_builtin__func__(sym->name);
for (i = 0; i < nmembers(&sym->type); ++i) {
name = get_member(&sym->type, i)->name;
type = get_member(&sym->type, i)->type;
symtype = SYM_DEFINITION;
linkage = LINK_NONE;
if (!name) {
error("Missing parameter name at position %d.", i + 1);
exit(1);
}
def->params = sym_list_add(def->params,
sym_add(&ns_ident, name, type, symtype, linkage));
}
parent = block(def->body);
pop_scope(&ns_ident);
return parent;
}
default:
break;
}
consume(',');
}
}
static bool shunting_yard(const TCHAR *input, TCHAR *output)
{
const TCHAR *strpos = input, *strend = input + _tcslen(input);
TCHAR c, *outpos = output;
TCHAR stack[STACK_SIZE]; // operator stack
unsigned int sl = 0; // stack length
TCHAR sc; // used for record stack element
while(strpos < strend) {
if (sl >= STACK_SIZE)
return false;
// read one token from the input stream
c = *strpos;
if(c != ' ') {
// If the token is a number (identifier), then add it to the output queue.
if(is_ident(c)) {
*outpos = c; ++outpos;
}
// If the token is a function token, then push it onto the stack.
else if(is_function(c)) {
stack[sl] = c;
++sl;
}
// If the token is a function argument separator (e.g., a comma):
else if(c == ',') {
bool pe = false;
while(sl > 0) {
sc = stack[sl - 1];
if(sc == '(') {
pe = true;
break;
}
else {
// Until the token at the top of the stack is a left parenthesis,
// pop operators off the stack onto the output queue.
*outpos = sc;
++outpos;
sl--;
}
}
// If no left parentheses are encountered, either the separator was misplaced
// or parentheses were mismatched.
if(!pe) {
calc_log ((_T("Error: separator or parentheses mismatched\n")));
return false;
}
}
// If the token is an operator, op1, then:
else if(is_operator(c)) {
while(sl > 0) {
sc = stack[sl - 1];
// While there is an operator token, o2, at the top of the stack
// op1 is left-associative and its precedence is less than or equal to that of op2,
// or op1 is right-associative and its precedence is less than that of op2,
if(is_operator(sc) &&
((op_left_assoc(c) && (op_preced(c) <= op_preced(sc))) ||
(!op_left_assoc(c) && (op_preced(c) < op_preced(sc))))) {
// Pop o2 off the stack, onto the output queue;
*outpos = sc;
++outpos;
sl--;
}
else {
break;
}
}
// push op1 onto the stack.
stack[sl] = c;
++sl;
}
// If the token is a left parenthesis, then push it onto the stack.
else if(c == '(') {
stack[sl] = c;
++sl;
}
// If the token is a right parenthesis:
else if(c == ')') {
bool pe = false;
// Until the token at the top of the stack is a left parenthesis,
// pop operators off the stack onto the output queue
while(sl > 0) {
sc = stack[sl - 1];
if(sc == '(') {
pe = true;
break;
}
else {
*outpos = sc;
++outpos;
sl--;
}
}
// If the stack runs out without finding a left parenthesis, then there are mismatched parentheses.
if(!pe) {
calc_log ((_T("Error: parentheses mismatched\n")));
return false;
}
// Pop the left parenthesis from the stack, but not onto the output queue.
sl--;
// If the token at the top of the stack is a function token, pop it onto the output queue.
if(sl > 0) {
sc = stack[sl - 1];
if(is_function(sc)) {
*outpos = sc;
++outpos;
sl--;
}
}
}
else {
calc_log ((_T("Unknown token %c\n"), c));
return false; // Unknown token
}
}
++strpos;
}
// When there are no more tokens to read:
// While there are still operator tokens in the stack:
while(sl > 0) {
sc = stack[sl - 1];
if(sc == '(' || sc == ')') {
printf("Error: parentheses mismatched\n");
return false;
}
*outpos = sc;
++outpos;
--sl;
}
*outpos = 0; // Null terminator
return true;
}
static bool execution_order(const TCHAR *input, double *outval)
{
const TCHAR *strpos = input, *strend = input + _tcslen(input);
TCHAR c, res[4];
unsigned int sl = 0, rn = 0;
struct calcstack stack[STACK_SIZE] = { {0, .0} }, *sc, *sc2;
double val = 0;
int i;
bool ok = false;
// While there are input tokens left
while(strpos < strend) {
if (sl >= STACK_SIZE)
return false;
// Read the next token from input.
c = *strpos;
// If the token is a value or identifier
if(is_ident(c)) {
// Push it onto the stack.
stack[sl].s = chartostack (c);
++sl;
}
// Otherwise, the token is an operator (operator here includes both operators, and functions).
else if(is_operator(c) || is_function(c)) {
_stprintf(res, _T("_%02d"), rn);
calc_log ((_T("%s = "), res));
++rn;
// It is known a priori that the operator takes n arguments.
unsigned int nargs = op_arg_count(c);
// If there are fewer than n values on the stack
if(sl < nargs) {
// (Error) The user has not input sufficient values in the expression.
return false;
}
// Else, Pop the top n values from the stack.
// Evaluate the operator, with the values as arguments.
if(is_function(c)) {
calc_log ((_T("%c("), c));
while(nargs > 0){
sc = &stack[sl - nargs]; // to remove reverse order of arguments
if(nargs > 1) {
calc_log ((_T("%s, "), sc));
}
else {
calc_log ((_T("%s)\n"), sc));
}
--nargs;
}
sl-=op_arg_count(c);
}
else {
if(nargs == 1) {
sc = &stack[sl - 1];
sl--;
val = docalc1 (c, sc, val);
calc_log ((_T("%c %s = %f;\n"), c, stacktostr(sc), val));
}
else {
sc = &stack[sl - 2];
calc_log ((_T("%s %c "), stacktostr(sc), c));
sc2 = &stack[sl - 1];
val = docalc2 (c, sc, sc2);
sl--;sl--;
calc_log ((_T("%s = %f;\n"), stacktostr(sc2), val));
}
}
// Push the returned results, if any, back onto the stack.
stack[sl].val = val;
stack[sl].s = NULL;
++sl;
}
++strpos;
}
// If there is only one value in the stack
// That value is the result of the calculation.
if(sl == 1) {
sc = &stack[sl - 1];
sl--;
calc_log ((_T("result = %f\n"), val));
if (outval)
*outval = val;
ok = true;
}
for (i = 0; i < STACK_SIZE; i++)
xfree (stack[i].s);
// If there are more values in the stack
// (Error) The user input has too many values.
return ok;
}
bool execution_order(const char *input) {
printf("order: (arguments in reverse order)\n");
const char *strpos = input, *strend = input + strlen(input);
char c, res[4];
unsigned int sl = 0, sc, stack[32], rn = 0;
// While there are input tokens left
while(strpos < strend) {
// Read the next token from input.
c = *strpos;
// If the token is a value or identifier
if(is_ident(c)) {
// Push it onto the stack.
stack[sl] = c;
++sl;
}
// Otherwise, the token is an operator (operator here includes both operators, and functions).
else if(is_operator(c) || is_function(c)) {
sprintf(res, "_%02d", rn);
printf("%s = ", res);
++rn;
// It is known a priori that the operator takes n arguments.
unsigned int nargs = op_arg_count(c);
// If there are fewer than n values on the stack
if(sl < nargs) {
// (Error) The user has not input sufficient values in the expression.
return false;
}
// Else, Pop the top n values from the stack.
// Evaluate the operator, with the values as arguments.
if(is_function(c)) {
printf("%c(", c);
while(nargs > 0) {
sc = stack[sl - 1];
sl--;
if(nargs > 1) {
printf("%s, ", &sc);
}
else {
printf("%s)\n", &sc);
}
--nargs;
}
}
else {
if(nargs == 1) {
sc = stack[sl - 1];
sl--;
printf("%c %s;\n", c, &sc);
}
else {
sc = stack[sl - 1];
sl--;
printf("%s %c ", &sc, c);
sc = stack[sl - 1];
sl--;
printf("%s;\n",&sc);
}
}
// Push the returned results, if any, back onto the stack.
stack[sl] = *(unsigned int*)res;
++sl;
}
++strpos;
}
// If there is only one value in the stack
// That value is the result of the calculation.
if(sl == 1) {
sc = stack[sl - 1];
sl--;
printf("%s is a result\n", &sc);
return true;
}
// If there are more values in the stack
// (Error) The user input has too many values.
return false;
}
spFile* CJSourceParser::Parse( char* start, char* end )
{
// set up state variables
mCurVis = SP_VIS_PRIVATE;
spFile* pTopCtx = new spFile();
mpCurCtx = pTopCtx;
mIsVirtual = 0;
mIsTemplate = 0;
mNestingLevel = 0;
m_cur = start;
mpStart = start;
mpEnd = end;
_gSrcEnd = mpEnd; // let all the C-functions "smell" the end of file
_gSrcStart = start;
_gLineNo = 0;
clear_commets_queue();
// main parsing loop
do
{
if ( !get_next_token( m_cur ) )
// end of source reached
return pTopCtx;
if ( memcmp( m_cur, "ScriptSection( const string&",
strlen( "ScriptSection( const string&" )
) == 0
)
{
// int o = 0;
// ++o;
}
switch (*m_cur)
{
case '#' :
{
AddMacroNode( m_cur );
continue;
}
case ':' :
{
skip_token( m_cur );
continue;
}
case ';' :
{
skip_token( m_cur );
continue;
}
case ')' :
{
skip_token( m_cur );
continue;
}
case '=' :
{
skip_token( m_cur );
continue;
}
default: break;
}
// 'const' is a part of the return type, not a keyword here
if ( strncmp(m_cur, "const", 5) != 0 && is_keyword( m_cur ) )
{
// parses, token, if token identifies
// the container context (e.g. class/namespace)
// the corresponding context object is created
// and set as current context
ParseKeyword( m_cur );
continue;
}
if ( *m_cur >= _T('0') && *m_cur <= _T('9') )
{
skip_token( m_cur );
continue;
}
if ( *m_cur == _T('}') )
{
if ( mCurCtxType != SP_CTX_CLASS )
{
// FOR NOW:: disable the below assertion
// DBG:: unexpected closing-bracket found
//ASSERT(0);
skip_token( m_cur ); // just skip it
continue;
}
if ( mpCurCtx->GetType() == SP_CTX_CLASS )
{
int curOfs = ( (m_cur+1) - _gSrcStart );
mpCurCtx->mContextLength = ( curOfs - mpCurCtx->mSrcOffset );
}
--mNestingLevel;
// terminate operation/class/namespace context
// TBD:: check if it's really this type of context
wxASSERT( mpCurCtx );
mpCurCtx = mpCurCtx->GetOutterContext();
wxASSERT( mpCurCtx );
if ( mNestingLevel == 0 )
{
mCurCtxType = SP_CTX_FILE;
// not-nested class delclaration finished,
// rest template flag in any case
mIsTemplate = 0;
}
skip_token( m_cur );
continue;
}
bool isAMacro = false;
if ( is_function( m_cur, isAMacro ) )
{
if ( isAMacro )
{
skip_token( m_cur );
continue;
}
char* savedPos = m_cur;
int tmpLnNo;
store_line_no( tmpLnNo );
wxUnusedVar( tmpLnNo );
isAMacro = false;
if ( !ParseNameAndRetVal( m_cur, isAMacro ) )
{
if ( !isAMacro )
{
m_cur = savedPos;
SkipFunction( m_cur );
}
continue;
}
if ( !ParseArguments( m_cur ) )
{
// failure while parsing arguments,
// remove enclosing operation context
spContext* pFailed = mpCurCtx;
mpCurCtx = mpCurCtx->GetOutterContext();
mpCurCtx->RemoveChild( pFailed );
skip_to_eol( m_cur );
//m_cur = savedPos;
}
else
{
// otherwise, successfully close operation context:
clear_commets_queue();
SkipFunctionBody( m_cur );
mpCurCtx = mpCurCtx->GetOutterContext();
// DBG::
wxASSERT( mpCurCtx );
}
}
else // otherwise it's declaration of a variable;
{
// now, the cursor point to the end of statement (';' token)
if ( mCurCtxType != SP_CTX_CLASS )
{
// non-class members are ignored
skip_token( m_cur ); // skip the end of statement
continue;
}
ParseMemberVar( m_cur );
}
} while( 1 );
}
Term ProcCoefVrt(Term t, List ind)
{
List l,pl,ml;
int ii;
Term a2;
int g=0, g5=0, re=0, im=0, abbr=0, cmplx=0;
if(!is_compound(t) || CompoundArity(t)>2 || !is_list(CompoundArg1(t)))
{
ErrorInfo(0);
puts("wrong parameters of CoefVrt function.");
return 0;
}
if(lagr_hash==NULL)
{
ErrorInfo(107);
puts("CoefVrt: no vertices");
return 0;
}
mmm=0;
if(CompoundArity(t)==2)
{
List ol=CompoundArg2(t);
if(!is_list(ol))
{
ErrorInfo(107);
puts("CoefVrt: second argument is not a list.");
return 0;
}
for(;ol;ol=ListTail(ol))
{
Term o=ListFirst(ol);
if(is_compound(o))
{
o=CompoundArg1(o);
if(!is_atom(o) || !is_particle(o,0))
{
ErrorInfo(0);
printf("CoefVrt: ");WriteTerm(o);
puts(" is not a particle.\n");
return 0;
}
mmm=o;
continue;
}
if(!is_atom(o))
{
ErrorInfo(0);
printf("CoefVrt: ");WriteTerm(o);
puts(" is not an option.\n");
return 0;
}
if(strcmp("gamma",AtomValue(o))==0)
{
g++;
continue;
}
if(strcmp("gamma5",AtomValue(o))==0)
{
g5++;
continue;
}
if(strcmp("re",AtomValue(o))==0)
{
re++;
continue;
}
if(strcmp("im",AtomValue(o))==0)
{
im++;
continue;
}
if(strcmp("abbr",AtomValue(o))==0)
{
abbr++;
continue;
}
{
ErrorInfo(0);
printf("CoefVrt: ");WriteTerm(o);
puts(" is not an option.\n");
return 0;
}
}
}
if(re&&im)
re=im=0;
pl=ConsumeCompoundArg(t,1);
for(l=pl;l;l=ListTail(l))
if(is_function(ListFirst(l),0))
ChangeList(l,CallFunction(ListFirst(l),0));
/* for(l=pl;l;l=ListTail(l))
{
Term aa=ListFirst(l);
if(is_compound(aa)&&CompoundName(aa)==A_ANTI)
ChangeList(l,GetAtomProperty(CompoundArg1(aa),A_ANTI));
}*/
pl=SortedList(pl,acmp);
l=finda2(pl,0);
if(mmm && !mmmpos)
{
ErrorInfo(0);
printf("CoefVrt: particle ");
WriteTerm(mmm);
puts(" not found in the vertex");
return 0;
}
if(is_empty_list(l))
{
ErrorInfo(108);
printf("CoefVrt: vertex ");
WriteTerm(pl);
puts(" not found");
return NewInteger(0);
}
a2=CopyTerm(ListFirst(l));
alg2_symmetrize(a2);
alg2_common_n(a2);
{
int sv=kill_gamma_pm;
kill_gamma_pm=1;
alg2_red_1pm5(a2);
kill_gamma_pm=sv;
}
alg2_recommon_n(a2);
ml=ConsumeCompoundArg(a2,5);
for(l=ml;l;l=ListTail(l))
{
List l1,ll;
int tg=0, tg5=0, tm=0;
for(l1=CompoundArgN(ListFirst(l),3);l1;l1=ListTail(l1))
{
Term tt=ListFirst(l1);
if(CompoundName(tt)==OPR_SPECIAL && CompoundArg1(tt)==A_GAMMA)
tg++;
if(CompoundName(tt)==OPR_SPECIAL && CompoundArg1(tt)==A_GAMMA5)
tg5++;
if(CompoundName(tt)==A_MOMENT && CompoundArg1(tt)==
NewInteger(mmmpos))
tm++;
}
if(g!=tg || g5!=tg5 || (mmm && !tm))
{
SetCompoundArg(ListFirst(l),1,0);
continue;
}
if(!re && !im)
continue;
for(l1=CompoundArg2(ListFirst(l));l1;l1=ListTail(l1))
if(GetAtomProperty(CompoundArg1(ListFirst(l1)),A_ANTI))
cmplx++;
}
if( (re||im) && !cmplx)
for(l=ml;l;l=ListTail(l))
{
List ll,l1;
if(CompoundArg1(ListFirst(l))==0)
continue;
ll=ConsumeCompoundArg(ListFirst(l),2);
for(l1=ll;l1;l1=ListTail(l1))
if(CompoundArg1(ListFirst(l1))==A_I)
break;
if( (re && l1) || (im && !l1) )
SetCompoundArg(ListFirst(l),1,0);
if(im && l1)
ll=CutFromList(ll,l1);
SetCompoundArg(ListFirst(l),2,ll);
}
rpt:
for(l=ml;l;l=ListTail(l))
if(CompoundArg1(ListFirst(l))==0)
{
ml=CutFromList(ml,l);
break;
}
if(l)
goto rpt;
SetCompoundArg(a2,5,ml);
alg2_recommon_n(a2);
alg2_common_s(a2);
alg2_red_cos(a2);
alg2_red_orth(a2);
alg2_red_sico(a2);
alg2_red_comsico(a2);
alg2_recommon_n(a2);
if(abbr)
{
int trisv=opTriHeu;
alg2_eval_vrt(a2);
doing_abbr=0;
opTriHeu=trisv;
}
{
int n,d;
Term cf;
Term res;
n=IntegerValue(CompoundArg1(CompoundArg2(a2)));
d=IntegerValue(CompoundArg2(CompoundArg2(a2)));
cf=l2expr(CompoundArgN(a2,3),n);
ml=CompoundArgN(a2,5);
if(ml==0)
return NewInteger(0);
res=l2expr(CompoundArg2(ListFirst(ml)),
IntegerValue(CompoundArg1(ListFirst(ml))));
for(l=ListTail(ml);l;l=ListTail(l))
{
Term ccc;
n=IntegerValue(CompoundArg1(ListFirst(l)));
ccc=l2expr(CompoundArg2(ListFirst(l)),n>0?n:-n);
if(n>0)
res=MakeCompound2(OPR_PLUS,res,ccc);
else
res=MakeCompound2(OPR_MINUS,res,ccc);
}
if(res==NewInteger(1))
res=cf;
else
res=MakeCompound2(OPR_MLT,cf,res);
if(d!=1)
res=MakeCompound2(OPR_DIV,res,NewInteger(d));
if( (im||re) && cmplx)
res=MakeCompound1(NewAtom(re?"creal":"cimag",0),res);
return res;
}
return a2;
}
static struct block *unary_expression(struct block *block)
{
struct var value;
switch (peek().token) {
case '&':
consume('&');
block = cast_expression(block);
block->expr = eval_addr(block, block->expr);
break;
case '*':
consume('*');
block = cast_expression(block);
block->expr = eval_deref(block, block->expr);
break;
case '!':
consume('!');
block = cast_expression(block);
block->expr = eval_expr(block, IR_OP_EQ, var_int(0), block->expr);
break;
case '~':
consume('~');
block = cast_expression(block);
block->expr = eval_expr(block, IR_NOT, block->expr);
break;
case '+':
consume('+');
block = cast_expression(block);
block->expr.lvalue = 0;
break;
case '-':
consume('-');
block = cast_expression(block);
block->expr = eval_expr(block, IR_OP_SUB, var_int(0), block->expr);
break;
case SIZEOF: {
struct typetree *type;
struct block *head = cfg_block_init(), *tail;
consume(SIZEOF);
if (peek().token == '(') {
switch (peekn(2).token) {
case FIRST(type_name):
consume('(');
type = declaration_specifiers(NULL);
if (peek().token != ')') {
type = declarator(type, NULL);
}
consume(')');
break;
default:
tail = unary_expression(head);
type = (struct typetree *) tail->expr.type;
break;
}
} else {
tail = unary_expression(head);
type = (struct typetree *) tail->expr.type;
}
if (is_function(type)) {
error("Cannot apply 'sizeof' to function type.");
}
if (!size_of(type)) {
error("Cannot apply 'sizeof' to incomplete type.");
}
block->expr = var_int(size_of(type));
break;
}
case INCREMENT:
consume(INCREMENT);
block = unary_expression(block);
value = block->expr;
block->expr = eval_expr(block, IR_OP_ADD, value, var_int(1));
block->expr = eval_assign(block, value, block->expr);
break;
case DECREMENT:
consume(DECREMENT);
block = unary_expression(block);
value = block->expr;
block->expr = eval_expr(block, IR_OP_SUB, value, var_int(1));
block->expr = eval_assign(block, value, block->expr);
break;
default:
block = postfix_expression(block);
break;
}
return block;
}
void infix2rpn(char *expr, RPNEntry ***rpne, int *nrpne) {
Array *rpn = array_new(32, 16);
Stack *stack_ops = stack_new(16);
//static char token[64];
char *token;
int tokenlen;
int i;
int uminus = 1;
int inoperand = 0;
//printf("%s:-> ", expr);
char lookahead;
for(token = gettoken(expr, &tokenlen, &lookahead);token != NULL; token = gettoken(NULL, &tokenlen, &lookahead)) {
if (uminus) {
if (*token == T_MINUS) {
*token = T_UMINUS;
}
uminus = 0;
}
if (is_function(token, tokenlen)) {
stack_push(stack_ops, token);
} else if (is_operand(token)) {
array_add(rpn, token);
} else if (is_arg_separator(token)) {
while(!stack_empty(stack_ops) && !is_lparen(stack_peek(stack_ops))) {
array_add(rpn, stack_pop(stack_ops));
}
} else if (is_operator(token)) {
uminus = 1;
if (stack_empty(stack_ops)) {
stack_push(stack_ops, token);
} else {
if (compare_ops(token, stack_peek(stack_ops))) {
array_add(rpn, stack_pop(stack_ops));
}
stack_push(stack_ops, token);
}
} else if (is_lparen(token)) {
uminus = 1;
stack_push(stack_ops, token);
} else if (is_rparen(token)) {
while(!stack_empty(stack_ops) && !is_lparen(stack_peek(stack_ops))) {
array_add(rpn, stack_pop(stack_ops));
}
stack_pop(stack_ops);
} else {
// errorski
}
}
while (!stack_empty(stack_ops)) {
array_add(rpn, stack_pop(stack_ops));
}
stack_free(&stack_ops);
*rpne = (RPNEntry **)malloc(rpn->count * sizeof(RPNEntry*));
for (i = 0; i < rpn->count; i++) {
token = array_get(rpn, i);
(*rpne)[i] = new_rpnentry(token, strlen(token));
}
*nrpne = rpn->count;
array_free(&rpn);
}
bool Type::compatible(const Type& type) const {
if (_types.size() == 0 or type._types.size() == 0) {
return true;
}
if (is_any()) {
return true;
}
if (this->is_primitive() && type.is_polymorphic()) {
return false;
}
if (this->temporary and not type.temporary) {
return false; // type not compatible with type&&
}
if (not this->constant and type.constant) {
return false; // 'const type' not compatible with 'type'
}
if ((is_array() && type.is_array()) || (is_set() && type.is_set()) || (is_map() && type.is_map()) || (is_function() && type.is_function())) {
return _types[0]->compatible(type._types[0].get());
}
if (_types[0] != type._types[0]) {
// 'Integer' is compatible with 'Float'
if (this->is_real() and type.is_integer()) {
return true;
}
// 'Boolean' is compatible with 'Integer'
if (this->is_integer() and type.is_bool()) {
return true;
}
// 'Integer' is compatible with 'Long'
if (this->is_long() and type.is_integer()) {
return true;
}
// All numbers types are compatible with the base 'Number' type
if (dynamic_cast<const Number_type*>(_types[0].get()) and (type.is_integer() or type.is_long() or type.is_real())) {
return true;
}
return false;
}
return true;
}
bool calls_function_by_value(Term* term)
{
return !is_function(term->function);
}
int cli_function(char str[], StudentList** sl, int* sl_length)
{
printf("\n");
if(is_function("PUSH", str)) return cli_push(sl, sl_length);
if(is_function("UNSHIFT", str)) return cli_unshift(sl, sl_length);
if(is_function("PRINT_ALL", str)) return cli_print_all(*sl);
if(is_function("LENGTH", str)) return cli_length(sl_length);
if(is_function("DELETE", str)) return cli_delete(sl, sl_length);
if(is_function("DELETE_ALL", str)) return cli_delete_all(*sl, sl_length);
if(is_function("FIND_ID", str)) return cli_find_id(*sl);
if(is_function("QUERY", str)) return cli_query(*sl);
if(is_function("SORT_STUDIENGANG", str)) return cli_sort_studiengang(*sl);
if(is_function("SORT_MARTRIKEL", str)) return cli_sort_martikel(*sl);
if(is_function("QUIT", str)) return 1;
printf("No such Function\n");
return 0;
}
static bool execute(char *buffer, bool *data)
{
char *token, **ops, *o1, *o2;
bool *output, res;
int n_o, n_q, sz_o, sz_q;;
sz_o = 8192;
sz_q = 8192;
ops = malloc(sz_q * sizeof(char *));
output = malloc(sz_o * sizeof(bool));
n_o = n_q = 0;
for (token = strtok(buffer, " "); token; token = strtok(NULL, " ")) {
if (strncmp(token, "b", 1) == 0) {
push_bit(data[atoi(token + 1)], &output, &n_o, &sz_o);
} else if (is_function(token)) {
push_op(token, &ops, &n_q, &sz_q);
} else if (strncmp(token, ",", 1) == 0) {
while (strncmp(peek_op(ops, n_q), "(", 1) != 0) {
token = pop_op(ops, &n_q);
if (is_operator(token)) {
push_bit(operator(token, pop_bit(output, &n_o), pop_bit(output, &n_o)), &output, &n_o, &sz_o);
} else {
push_bit(function(token, output, &n_o), &output, &n_o, &sz_o);
}
}
} else if (is_operator(token)) {
o1 = token;
while (peek_op(ops, n_q) && is_operator(peek_op(ops, n_q))) {
o2 = peek_op(ops, n_q);
if (operator_precedence(o1) <= operator_precedence(o2)) {
push_bit(operator(pop_op(ops, &n_q), pop_bit(output, &n_o), pop_bit(output, &n_o)), &output, &n_o, &sz_o);
} else {
break;
}
}
push_op(o1, &ops, &n_q, &sz_q);
} else if (strncmp(token, "(", 1) == 0) {
push_op(token, &ops, &n_q, &sz_q);
} else if (strncmp(token, ")", 1) == 0) {
while (strncmp(peek_op(ops, n_q), "(", 1) != 0) {
token = pop_op(ops, &n_q);
if (is_operator(token)) {
push_bit(operator(token, pop_bit(output, &n_o), pop_bit(output, &n_o)), &output, &n_o, &sz_o);
} else {
push_bit(function(token, output, &n_o), &output, &n_o, &sz_o);
}
}
token = pop_op(ops, &n_q); /* pop the left bracket */
if (peek_op(ops, n_q) && is_function(peek_op(ops, n_q))) {
push_bit(function(pop_op(ops, &n_q), output, &n_o), &output, &n_o, &sz_o);
}
} else {
fprintf(stderr, "ERROR: unknown symbol: %s\n", token);
exit(EXIT_FAILURE);
}
}
while ((token = pop_op(ops, &n_q))) {
if (is_operator(token)) {
push_bit(operator(token, pop_bit(output, &n_o), pop_bit(output, &n_o)), &output, &n_o, &sz_o);
} else {
push_bit(function(token, output, &n_o), &output, &n_o, &sz_o);
}
}
res = output[0];
free(output);
free(ops);
return res;
}
static struct block *postfix_expression(struct block *block)
{
struct var root;
block = primary_expression(block);
root = block->expr;
while (1) {
const struct member *field;
const struct typetree *type;
struct var expr, copy, *arg;
struct token tok;
int i, j;
switch ((tok = peek()).token) {
case '[':
do {
/* Evaluate a[b] = *(a + b). The semantics of pointer arithmetic
* takes care of multiplying b with the correct width. */
consume('[');
block = expression(block);
root = eval_expr(block, IR_OP_ADD, root, block->expr);
root = eval_deref(block, root);
consume(']');
} while (peek().token == '[');
break;
case '(':
type = root.type;
if (is_pointer(root.type) && is_function(root.type->next))
type = type_deref(root.type);
else if (!is_function(root.type)) {
error("Expression must have type pointer to function, was %t.",
root.type);
exit(1);
}
consume('(');
arg = calloc(nmembers(type), sizeof(*arg));
for (i = 0; i < nmembers(type); ++i) {
if (peek().token == ')') {
error("Too few arguments, expected %d but got %d.",
nmembers(type), i);
exit(1);
}
block = assignment_expression(block);
arg[i] = block->expr;
/* todo: type check here. */
if (i < nmembers(type) - 1) {
consume(',');
}
}
while (is_vararg(type) && peek().token != ')') {
consume(',');
arg = realloc(arg, (i + 1) * sizeof(*arg));
block = assignment_expression(block);
arg[i] = block->expr;
i++;
}
consume(')');
for (j = 0; j < i; ++j)
param(block, arg[j]);
free(arg);
root = eval_call(block, root);
break;
case '.':
consume('.');
tok = consume(IDENTIFIER);
field = find_type_member(root.type, tok.strval);
if (!field) {
error("Invalid field access, no member named '%s'.",
tok.strval);
exit(1);
}
root.type = field->type;
root.offset += field->offset;
break;
case ARROW:
consume(ARROW);
tok = consume(IDENTIFIER);
if (is_pointer(root.type) && is_struct_or_union(root.type->next)) {
field = find_type_member(type_deref(root.type), tok.strval);
if (!field) {
error("Invalid field access, no member named '%s'.",
tok.strval);
exit(1);
}
/* Make it look like a pointer to the field type, then perform
* normal dereferencing. */
root.type = type_init(T_POINTER, field->type);
root = eval_deref(block, root);
root.offset = field->offset;
} else {
error("Invalid field access.");
exit(1);
}
break;
case INCREMENT:
consume(INCREMENT);
copy = create_var(root.type);
eval_assign(block, copy, root);
expr = eval_expr(block, IR_OP_ADD, root, var_int(1));
eval_assign(block, root, expr);
root = copy;
break;
case DECREMENT:
consume(DECREMENT);
copy = create_var(root.type);
eval_assign(block, copy, root);
expr = eval_expr(block, IR_OP_SUB, root, var_int(1));
eval_assign(block, root, expr);
root = copy;
break;
default:
block->expr = root;
return block;
}
}
}