pike.git/src/program.c:5174:
free_string(n);
free_type(t);
return ret;
}
/* type is a serialized tokenized type. */
PMOD_EXPORT int quick_map_variable(const char *name,
int name_length,
size_t offset,
const char *type,
- int type_length,
+ int UNUSED(type_length),
INT32 run_time_type,
INT32 flags)
{
int ret;
struct pike_string *n;
struct pike_type *t;
n = make_shared_binary_string(name, name_length);
t = make_pike_type(type);
pike.git/src/program.c:6483:
return i;
reference_shared_string(str);
add_to_strings(str);
return i;
}
/* NOTE: O(n²)! */
int store_constant(const struct svalue *foo,
int equal,
- struct pike_string *constant_name)
+ struct pike_string *UNUSED(constant_name))
{
struct program_constant tmp;
volatile unsigned int e;
JMP_BUF jmp;
if (SETJMP(jmp)) {
handle_compile_exception ("Error comparing constants.");
/* Assume that if `==() throws an error, the svalues aren't equal. */
e = Pike_compiler->new_program->num_constants;
} else {
pike.git/src/program.c:9717:
/*! @class CompilerState
*!
*! Keeps the state of a single program/class during compilation.
*!
*! @note
*! Not in use yet!
*/
#define THIS_PROGRAM_STATE ((struct program_state *)(Pike_fp->current_storage))
- static void program_state_event_handler(int event)
+ static void program_state_event_handler(int UNUSED(event))
{
#if 0
struct program_state *c = THIS_PROGRAM_STATE;
switch (event) {
case PROG_EVENT_INIT:
#define INIT
#include "compilation.h"
break;
case PROG_EVENT_EXIT:
#define EXIT
pike.git/src/program.c:10145:
}
free_string(name_tmp);
free_type(type_tmp);
return ret;
}
PMOD_EXPORT int quick_add_function(const char *name,
int name_length,
void (*cfun)(INT32),
const char *type,
- int type_length,
+ int UNUSED(type_length),
unsigned flags,
unsigned opt_flags)
{
int ret;
struct pike_string *name_tmp;
struct pike_type *type_tmp;
union idptr tmp;
/* fprintf(stderr,"ADD_FUNC: %s\n",name); */
name_tmp = make_shared_binary_string(name, name_length);
type_tmp = make_pike_type(type);
pike.git/src/program.c:10211: Inside #if defined(PIKE_DEBUG)
}
#endif
}
#endif
#undef THIS
#define THIS ((struct pike_trampoline *)(CURRENT_STORAGE))
struct program *pike_trampoline_program=0;
- static void apply_trampoline(INT32 args)
+ static void apply_trampoline(INT32 UNUSED(args))
{
Pike_error("Internal error: Trampoline magic failed!\n");
}
static void not_trampoline(INT32 args)
{
pop_n_elems(args);
if (!THIS->frame || !THIS->frame->current_object ||
!THIS->frame->current_object->prog) {
push_int(1);
pike.git/src/program.c:10249:
ref_push_function (THIS->frame->current_object, THIS->func);
init_buf(&save_buf);
describe_svalue (sp - 1, 0, 0);
str = complex_free_buf(&save_buf);
pop_stack();
push_string (make_shared_binary_string (str.str, str.len));
free (str.str);
}
- static void init_trampoline(struct object *o)
+ static void init_trampoline(struct object *UNUSED(o))
{
THIS->frame=0;
}
- static void exit_trampoline(struct object *o)
+ static void exit_trampoline(struct object *UNUSED(o))
{
if(THIS->frame)
{
free_pike_scope(THIS->frame);
THIS->frame=0;
}
}
static void gc_check_frame(struct pike_frame *f)
{
pike.git/src/program.c:10277:
if(f->current_object)
debug_gc_check (f->current_object, " as current_object in trampoline frame");
if(f->current_program)
debug_gc_check (f->current_program, " as current_program in trampoline frame");
debug_gc_check_svalues (f->locals, f->num_locals, " in locals of trampoline frame");
if(f->scope && !debug_gc_check (f->scope, " as scope frame of trampoline frame"))
gc_check_frame(f->scope);
}
}
- static void gc_check_trampoline(struct object *o)
+ static void gc_check_trampoline(struct object *UNUSED(o))
{
if (THIS->frame &&
!debug_gc_check (THIS->frame, " as trampoline frame"))
gc_check_frame(THIS->frame);
}
static void gc_recurse_frame(struct pike_frame *f)
{
if(f->current_object) gc_recurse_object(f->current_object);
if(f->current_program) gc_recurse_program(f->current_program);
if(f->flags & PIKE_FRAME_MALLOCED_LOCALS)
gc_recurse_svalues(f->locals,f->num_locals);
if(f->scope) gc_recurse_frame(f->scope);
}
- static void gc_recurse_trampoline(struct object *o)
+ static void gc_recurse_trampoline(struct object *UNUSED(o))
{
if (THIS->frame) gc_recurse_frame(THIS->frame);
}
/* This placeholder should be used
* in the first compiler pass to take the place
* of unknown things
*/
struct program *placeholder_program;