[svn:parrot] r42917 - in trunk/src: . call gc interp io runcore string
fperrad at svn.parrot.org
fperrad at svn.parrot.org
Sun Dec 6 14:56:12 UTC 2009
Author: fperrad
Date: Sun Dec 6 14:56:10 2009
New Revision: 42917
URL: https://trac.parrot.org/parrot/changeset/42917
Log:
[cage] improve C indentation, see TT #1329
Modified:
trunk/src/call/args.c
trunk/src/call/ops.c
trunk/src/debug.c
trunk/src/embed.c
trunk/src/events.c
trunk/src/frame_builder.c
trunk/src/gc/mark_sweep.c
trunk/src/hash.c
trunk/src/interp/inter_cb.c
trunk/src/interp/inter_misc.c
trunk/src/io/buffer.c
trunk/src/io/filehandle.c
trunk/src/key.c
trunk/src/list.c
trunk/src/multidispatch.c
trunk/src/nci_test.c
trunk/src/oo.c
trunk/src/packdump.c
trunk/src/packfile.c
trunk/src/packout.c
trunk/src/pbc_disassemble.c
trunk/src/pbc_dump.c
trunk/src/pbc_merge.c
trunk/src/pmc_freeze.c
trunk/src/runcore/main.c
trunk/src/runcore/trace.c
trunk/src/scheduler.c
trunk/src/spf_render.c
trunk/src/spf_vtable.c
trunk/src/string/api.c
trunk/src/string/primitives.c
Modified: trunk/src/call/args.c
==============================================================================
--- trunk/src/call/args.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/call/args.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -592,24 +592,24 @@
const INTVAL raw_index = raw_args[arg_index + 2];
switch (PARROT_ARG_TYPE_MASK_MASK(arg_flags)) {
- case PARROT_ARG_INTVAL:
- if (constant)
- VTABLE_push_integer(interp, call_object, raw_index);
- else {
- const INTVAL int_value = CTX_REG_INT(ctx, raw_index);
- VTABLE_push_integer(interp, call_object, int_value);
- }
- break;
- case PARROT_ARG_FLOATVAL:
- if (constant)
- VTABLE_push_float(interp, call_object,
+ case PARROT_ARG_INTVAL:
+ if (constant)
+ VTABLE_push_integer(interp, call_object, raw_index);
+ else {
+ const INTVAL int_value = CTX_REG_INT(ctx, raw_index);
+ VTABLE_push_integer(interp, call_object, int_value);
+ }
+ break;
+ case PARROT_ARG_FLOATVAL:
+ if (constant)
+ VTABLE_push_float(interp, call_object,
Parrot_pcc_get_num_constant(interp, ctx, raw_index));
- else {
- const FLOATVAL float_value = CTX_REG_NUM(ctx, raw_index);
- VTABLE_push_float(interp, call_object, float_value);
- }
- break;
- case PARROT_ARG_STRING:
+ else {
+ const FLOATVAL float_value = CTX_REG_NUM(ctx, raw_index);
+ VTABLE_push_float(interp, call_object, float_value);
+ }
+ break;
+ case PARROT_ARG_STRING:
{
STRING *string_value;
if (constant)
@@ -635,7 +635,7 @@
break;
}
- case PARROT_ARG_PMC:
+ case PARROT_ARG_PMC:
{
PMC *pmc_value;
if (constant)
@@ -652,8 +652,8 @@
break;
}
- default:
- break;
+ default:
+ break;
}
}
@@ -687,41 +687,41 @@
const INTVAL raw_index = raw_args[arg_index + 2];
switch (PARROT_ARG_TYPE_MASK_MASK(arg_flags)) {
- case PARROT_ARG_INTVAL:
- if (constant)
- VTABLE_set_integer_keyed_str(interp, call_object, name, raw_index);
- else
- VTABLE_set_integer_keyed_str(interp, call_object, name,
+ case PARROT_ARG_INTVAL:
+ if (constant)
+ VTABLE_set_integer_keyed_str(interp, call_object, name, raw_index);
+ else
+ VTABLE_set_integer_keyed_str(interp, call_object, name,
CTX_REG_INT(ctx, raw_index));
- break;
- case PARROT_ARG_FLOATVAL:
- if (constant)
- VTABLE_set_number_keyed_str(interp, call_object, name,
+ break;
+ case PARROT_ARG_FLOATVAL:
+ if (constant)
+ VTABLE_set_number_keyed_str(interp, call_object, name,
Parrot_pcc_get_num_constant(interp, ctx, raw_index));
- else
- VTABLE_set_number_keyed_str(interp, call_object, name,
+ else
+ VTABLE_set_number_keyed_str(interp, call_object, name,
CTX_REG_NUM(ctx, raw_index));
- break;
- case PARROT_ARG_STRING:
- if (constant)
- /* ensure that callees don't modify constant caller strings */
- VTABLE_set_string_keyed_str(interp, call_object, name,
+ break;
+ case PARROT_ARG_STRING:
+ if (constant)
+ /* ensure that callees don't modify constant caller strings */
+ VTABLE_set_string_keyed_str(interp, call_object, name,
Parrot_str_new_COW(interp,
Parrot_pcc_get_string_constant(interp, ctx, raw_index)));
- else
- VTABLE_set_string_keyed_str(interp, call_object, name,
+ else
+ VTABLE_set_string_keyed_str(interp, call_object, name,
CTX_REG_STR(ctx, raw_index));
- break;
- case PARROT_ARG_PMC:
- if (constant)
- VTABLE_set_pmc_keyed_str(interp, call_object, name,
+ break;
+ case PARROT_ARG_PMC:
+ if (constant)
+ VTABLE_set_pmc_keyed_str(interp, call_object, name,
Parrot_pcc_get_pmc_constant(interp, ctx, raw_index));
- else
+ else
VTABLE_set_pmc_keyed_str(interp, call_object, name,
CTX_REG_PMC(ctx, raw_index));
- break;
- default:
- break;
+ break;
+ default:
+ break;
}
}
@@ -833,32 +833,32 @@
/* Returns store a pointer to the register, so they can pass
* the result back to the caller. */
switch (PARROT_ARG_TYPE_MASK_MASK(arg_flags)) {
- case PARROT_ARG_INTVAL:
- csr_push_pointer(interp, call_object, &(CTX_REG_INT(ctx, raw_index)),
+ case PARROT_ARG_INTVAL:
+ csr_push_pointer(interp, call_object, &(CTX_REG_INT(ctx, raw_index)),
PARROT_ARG_INTVAL);
- break;
- case PARROT_ARG_FLOATVAL:
- csr_push_pointer(interp, call_object, &(CTX_REG_NUM(ctx, raw_index)),
+ break;
+ case PARROT_ARG_FLOATVAL:
+ csr_push_pointer(interp, call_object, &(CTX_REG_NUM(ctx, raw_index)),
PARROT_ARG_FLOATVAL);
- break;
- case PARROT_ARG_STRING:
- if (arg_flags & PARROT_ARG_NAME) {
- STRING * string_val = arg_flags & PARROT_ARG_CONSTANT
- ? Parrot_pcc_get_string_constant(interp, ctx, raw_index)
- : CTX_REG_STR(ctx, raw_index);
- csr_push_pointer(interp, call_object, string_val, PARROT_ARG_STRING);
- }
- else {
- csr_push_pointer(interp, call_object,
+ break;
+ case PARROT_ARG_STRING:
+ if (arg_flags & PARROT_ARG_NAME) {
+ STRING * string_val = arg_flags & PARROT_ARG_CONSTANT
+ ? Parrot_pcc_get_string_constant(interp, ctx, raw_index)
+ : CTX_REG_STR(ctx, raw_index);
+ csr_push_pointer(interp, call_object, string_val, PARROT_ARG_STRING);
+ }
+ else {
+ csr_push_pointer(interp, call_object,
&(CTX_REG_STR(ctx, raw_index)), PARROT_ARG_STRING);
- }
- break;
- case PARROT_ARG_PMC:
- csr_push_pointer(interp, call_object, &(CTX_REG_PMC(ctx, raw_index)),
+ }
+ break;
+ case PARROT_ARG_PMC:
+ csr_push_pointer(interp, call_object, &(CTX_REG_PMC(ctx, raw_index)),
PARROT_ARG_PMC);
- break;
- default:
- break;
+ break;
+ default:
+ break;
}
}
@@ -912,24 +912,24 @@
/* Returns store the original passed-in pointer so they can pass
* the result back to the caller. */
switch (type) {
- case 'I':
- csr_push_pointer(interp, call_object,
+ case 'I':
+ csr_push_pointer(interp, call_object,
(void *)va_arg(args, INTVAL *), PARROT_ARG_INTVAL);
- break;
- case 'N':
- csr_push_pointer(interp, call_object,
+ break;
+ case 'N':
+ csr_push_pointer(interp, call_object,
(void *)va_arg(args, FLOATVAL *), PARROT_ARG_FLOATVAL);
- break;
- case 'S':
- csr_push_pointer(interp, call_object,
+ break;
+ case 'S':
+ csr_push_pointer(interp, call_object,
(void *)va_arg(args, STRING **), PARROT_ARG_STRING);
- break;
- case 'P':
- csr_push_pointer(interp, call_object,
+ break;
+ case 'P':
+ csr_push_pointer(interp, call_object,
(void *)va_arg(args, PMC **), PARROT_ARG_PMC);
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL,
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL,
EXCEPTION_INVALID_OPERATION,
"Dispatch: invalid argument type %c!", type);
}
@@ -937,16 +937,16 @@
else {
/* Regular arguments just set the value */
switch (type) {
- case 'I':
- VTABLE_push_integer(interp, call_object, va_arg(args, INTVAL));
- break;
- case 'N':
- VTABLE_push_float(interp, call_object, va_arg(args, FLOATVAL));
- break;
- case 'S':
- VTABLE_push_string(interp, call_object, va_arg(args, STRING *));
- break;
- case 'P':
+ case 'I':
+ VTABLE_push_integer(interp, call_object, va_arg(args, INTVAL));
+ break;
+ case 'N':
+ VTABLE_push_float(interp, call_object, va_arg(args, FLOATVAL));
+ break;
+ case 'S':
+ VTABLE_push_string(interp, call_object, va_arg(args, STRING *));
+ break;
+ case 'P':
{
INTVAL type_lookahead = sig[i+1];
PMC * const pmc_arg = va_arg(args, PMC *);
@@ -967,12 +967,12 @@
}
break;
}
- case '-':
- i++; /* skip '>' */
- in_return_sig = 1;
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL,
+ case '-':
+ i++; /* skip '>' */
+ in_return_sig = 1;
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL,
EXCEPTION_INVALID_OPERATION,
"Dispatch: invalid argument type %c!", type);
}
@@ -1140,26 +1140,26 @@
/* Go ahead and fill the parameter with a positional argument. */
switch (PARROT_ARG_TYPE_MASK_MASK(param_flags)) {
- case PARROT_ARG_INTVAL:
- *accessor->intval(interp, arg_info, param_index) =
+ case PARROT_ARG_INTVAL:
+ *accessor->intval(interp, arg_info, param_index) =
VTABLE_get_integer_keyed_int(interp, call_object, arg_index);
- break;
- case PARROT_ARG_FLOATVAL:
- *accessor->numval(interp, arg_info, param_index) =
+ break;
+ case PARROT_ARG_FLOATVAL:
+ *accessor->numval(interp, arg_info, param_index) =
VTABLE_get_number_keyed_int(interp, call_object, arg_index);
- break;
- case PARROT_ARG_STRING:
- *accessor->string(interp, arg_info, param_index) =
+ break;
+ case PARROT_ARG_STRING:
+ *accessor->string(interp, arg_info, param_index) =
VTABLE_get_string_keyed_int(interp, call_object, arg_index);
- break;
- case PARROT_ARG_PMC:
- *accessor->pmc(interp, arg_info, param_index) =
+ break;
+ case PARROT_ARG_PMC:
+ *accessor->pmc(interp, arg_info, param_index) =
VTABLE_get_pmc_keyed_int(interp, call_object, arg_index);
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL,
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL,
EXCEPTION_INVALID_OPERATION, "invalid parameter type");
- break;
+ break;
}
/* Mark the option flag for the filled parameter. */
@@ -1305,26 +1305,26 @@
/* Fill the named parameter. */
switch (PARROT_ARG_TYPE_MASK_MASK(param_flags)) {
- case PARROT_ARG_INTVAL:
- *accessor->intval(interp, arg_info, param_index) =
+ case PARROT_ARG_INTVAL:
+ *accessor->intval(interp, arg_info, param_index) =
VTABLE_get_integer_keyed_str(interp, call_object, param_name);
- break;
- case PARROT_ARG_FLOATVAL:
- *accessor->numval(interp, arg_info, param_index) =
+ break;
+ case PARROT_ARG_FLOATVAL:
+ *accessor->numval(interp, arg_info, param_index) =
VTABLE_get_number_keyed_str(interp, call_object, param_name);
- break;
- case PARROT_ARG_STRING:
- *accessor->string(interp, arg_info, param_index) =
+ break;
+ case PARROT_ARG_STRING:
+ *accessor->string(interp, arg_info, param_index) =
VTABLE_get_string_keyed_str(interp, call_object, param_name);
- break;
- case PARROT_ARG_PMC:
- *accessor->pmc(interp, arg_info, param_index) =
+ break;
+ case PARROT_ARG_PMC:
+ *accessor->pmc(interp, arg_info, param_index) =
VTABLE_get_pmc_keyed_str(interp, call_object, param_name);
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL,
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL,
EXCEPTION_INVALID_OPERATION, "invalid parameter type");
- break;
+ break;
}
/* Mark the option flag for the filled parameter. */
@@ -1435,22 +1435,22 @@
{
ASSERT_ARGS(assign_default_param_value)
switch (PARROT_ARG_TYPE_MASK_MASK(param_flags)) {
- case PARROT_ARG_INTVAL:
- *accessor->intval(interp, arg_info, param_index) = 0;
- break;
- case PARROT_ARG_FLOATVAL:
- *accessor->numval(interp, arg_info, param_index) = 0.0;
- break;
- case PARROT_ARG_STRING:
- *accessor->string(interp, arg_info, param_index) = NULL;
- break;
- case PARROT_ARG_PMC:
- *accessor->pmc(interp, arg_info, param_index) = PMCNULL;
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL,
+ case PARROT_ARG_INTVAL:
+ *accessor->intval(interp, arg_info, param_index) = 0;
+ break;
+ case PARROT_ARG_FLOATVAL:
+ *accessor->numval(interp, arg_info, param_index) = 0.0;
+ break;
+ case PARROT_ARG_STRING:
+ *accessor->string(interp, arg_info, param_index) = NULL;
+ break;
+ case PARROT_ARG_PMC:
+ *accessor->pmc(interp, arg_info, param_index) = PMCNULL;
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL,
EXCEPTION_INVALID_OPERATION, "invalid parameter type");
- break;
+ break;
}
}
@@ -1470,22 +1470,22 @@
{
ASSERT_ARGS(assign_default_result_value)
switch (PARROT_ARG_TYPE_MASK_MASK(result_flags)) {
- case PARROT_ARG_INTVAL:
- csr_fill_integer(interp, results, index, 0);
- break;
- case PARROT_ARG_FLOATVAL:
- csr_fill_number(interp, results, index, 0.0);
- break;
- case PARROT_ARG_STRING:
- csr_fill_string(interp, results, index, NULL);
- break;
- case PARROT_ARG_PMC:
- csr_fill_pmc(interp, results, index, PMCNULL);
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL,
+ case PARROT_ARG_INTVAL:
+ csr_fill_integer(interp, results, index, 0);
+ break;
+ case PARROT_ARG_FLOATVAL:
+ csr_fill_number(interp, results, index, 0.0);
+ break;
+ case PARROT_ARG_STRING:
+ csr_fill_string(interp, results, index, NULL);
+ break;
+ case PARROT_ARG_PMC:
+ csr_fill_pmc(interp, results, index, PMCNULL);
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL,
EXCEPTION_INVALID_OPERATION, "invalid parameter type");
- break;
+ break;
}
}
@@ -1709,22 +1709,22 @@
constant = PARROT_ARG_CONSTANT_ISSET(return_flags);
switch (PARROT_ARG_TYPE_MASK_MASK(return_flags)) {
- case PARROT_ARG_INTVAL:
- VTABLE_push_integer(interp, collect_positional, constant?
+ case PARROT_ARG_INTVAL:
+ VTABLE_push_integer(interp, collect_positional, constant?
accessor->intval_constant(interp, return_info, return_index)
:accessor->intval(interp, return_info, return_index));
- break;
- case PARROT_ARG_FLOATVAL:
- VTABLE_push_float(interp, collect_positional, constant?
+ break;
+ case PARROT_ARG_FLOATVAL:
+ VTABLE_push_float(interp, collect_positional, constant?
accessor->numval_constant(interp, return_info, return_index)
:accessor->numval(interp, return_info, return_index));
- break;
- case PARROT_ARG_STRING:
- VTABLE_push_string(interp, collect_positional, constant?
+ break;
+ case PARROT_ARG_STRING:
+ VTABLE_push_string(interp, collect_positional, constant?
accessor->string_constant(interp, return_info, return_index)
:accessor->string(interp, return_info, return_index));
- break;
- case PARROT_ARG_PMC:
+ break;
+ case PARROT_ARG_PMC:
{
PMC *return_item = (constant)
? accessor->pmc_constant(interp, return_info, return_index)
@@ -1748,10 +1748,10 @@
VTABLE_push_pmc(interp, collect_positional, return_item);
break;
}
- default:
- Parrot_ex_throw_from_c_args(interp, NULL,
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL,
EXCEPTION_INVALID_OPERATION, "invalid return type");
- break;
+ break;
}
return_index++;
}
@@ -1793,67 +1793,67 @@
/* Go ahead and fill the result with a positional return. */
switch (PARROT_ARG_TYPE_MASK_MASK(return_flags)) {
- case PARROT_ARG_INTVAL:
- if (constant)
- csr_fill_integer(interp, call_object, result_index,
+ case PARROT_ARG_INTVAL:
+ if (constant)
+ csr_fill_integer(interp, call_object, result_index,
accessor->intval_constant(interp, return_info, return_index));
- else
- csr_fill_integer(interp, call_object, result_index,
+ else
+ csr_fill_integer(interp, call_object, result_index,
accessor->intval(interp, return_info, return_index));
- break;
- case PARROT_ARG_FLOATVAL:
- if (constant)
- csr_fill_number(interp, call_object, result_index,
+ break;
+ case PARROT_ARG_FLOATVAL:
+ if (constant)
+ csr_fill_number(interp, call_object, result_index,
accessor->numval_constant(interp, return_info, return_index));
- else
- csr_fill_number(interp, call_object, result_index,
+ else
+ csr_fill_number(interp, call_object, result_index,
accessor->numval(interp, return_info, return_index));
- break;
- case PARROT_ARG_STRING:
- if (constant)
- csr_fill_string(interp, call_object, result_index,
+ break;
+ case PARROT_ARG_STRING:
+ if (constant)
+ csr_fill_string(interp, call_object, result_index,
accessor->string_constant(interp, return_info, return_index));
- else
+ else
csr_fill_string(interp, call_object, result_index,
accessor->string(interp, return_info, return_index));
- break;
- case PARROT_ARG_PMC:
- {
- PMC *return_item = (constant)
- ? accessor->pmc_constant(interp, return_info, return_index)
- : accessor->pmc(interp, return_info, return_index);
- if (return_flags & PARROT_ARG_FLATTEN) {
- INTVAL flat_elems;
- if (!VTABLE_does(interp, return_item, CONST_STRING(interp, "array"))) {
- Parrot_ex_throw_from_c_args(interp, NULL,
+ break;
+ case PARROT_ARG_PMC:
+ {
+ PMC *return_item = (constant)
+ ? accessor->pmc_constant(interp, return_info, return_index)
+ : accessor->pmc(interp, return_info, return_index);
+ if (return_flags & PARROT_ARG_FLATTEN) {
+ INTVAL flat_elems;
+ if (!VTABLE_does(interp, return_item, CONST_STRING(interp, "array"))) {
+ Parrot_ex_throw_from_c_args(interp, NULL,
EXCEPTION_INVALID_OPERATION,
"flattened return on a non-array");
- }
- flat_elems = VTABLE_elements(interp, return_item);
- if (flat_elems == 0) {
- /* Skip empty aggregate */
- break;
- }
- if (return_subindex < flat_elems) {
- /* fetch an item out of the aggregate */
- return_item = VTABLE_get_pmc_keyed_int(interp, return_item,
+ }
+ flat_elems = VTABLE_elements(interp, return_item);
+ if (flat_elems == 0) {
+ /* Skip empty aggregate */
+ break;
+ }
+ if (return_subindex < flat_elems) {
+ /* fetch an item out of the aggregate */
+ return_item = VTABLE_get_pmc_keyed_int(interp, return_item,
return_subindex);
- return_subindex++;
- }
- if (return_subindex >= flat_elems) {
- return_subindex = 0; /* reset */
- }
- else {
- return_index--; /* we want to stay on the same item */
- }
+ return_subindex++;
+ }
+ if (return_subindex >= flat_elems) {
+ return_subindex = 0; /* reset */
+ }
+ else {
+ return_index--; /* we want to stay on the same item */
}
- csr_fill_pmc(interp, call_object, result_index, return_item);
- break;
}
- default:
- Parrot_ex_throw_from_c_args(interp, NULL,
- EXCEPTION_INVALID_OPERATION, "invalid return type");
+ csr_fill_pmc(interp, call_object, result_index, return_item);
break;
+ }
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL,
+ EXCEPTION_INVALID_OPERATION, "invalid return type");
+ break;
}
/* Mark the option flag for the filled result. */
@@ -1945,40 +1945,40 @@
constant = PARROT_ARG_CONSTANT_ISSET(return_flags);
switch (PARROT_ARG_TYPE_MASK_MASK(return_flags)) {
- case PARROT_ARG_INTVAL:
- VTABLE_set_integer_keyed_str(interp, named_return_list, return_name,
+ case PARROT_ARG_INTVAL:
+ VTABLE_set_integer_keyed_str(interp, named_return_list, return_name,
constant
? accessor->intval_constant(interp, return_info, return_index)
: accessor->intval(interp, return_info, return_index));
- break;
- case PARROT_ARG_FLOATVAL:
- VTABLE_set_number_keyed_str(interp, named_return_list, return_name,
+ break;
+ case PARROT_ARG_FLOATVAL:
+ VTABLE_set_number_keyed_str(interp, named_return_list, return_name,
constant
? accessor->numval_constant(interp, return_info, return_index)
: accessor->numval(interp, return_info, return_index));
- break;
- case PARROT_ARG_STRING:
- VTABLE_set_string_keyed_str(interp, named_return_list, return_name,
+ break;
+ case PARROT_ARG_STRING:
+ VTABLE_set_string_keyed_str(interp, named_return_list, return_name,
constant
? accessor->string_constant(interp, return_info, return_index)
: accessor->string(interp, return_info, return_index));
- break;
- case PARROT_ARG_PMC:
- if (0) {
- PMC *return_item = (constant)
- ? accessor->pmc_constant(interp, return_info, return_index)
- : accessor->pmc(interp, return_info, return_index);
- if (return_flags & PARROT_ARG_FLATTEN) {
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION,
- "named flattened returns not yet implemented");
- }
- VTABLE_set_pmc_keyed_str(interp, named_return_list, return_name, return_item);
- break;
+ break;
+ case PARROT_ARG_PMC:
+ if (0) {
+ PMC *return_item = (constant)
+ ? accessor->pmc_constant(interp, return_info, return_index)
+ : accessor->pmc(interp, return_info, return_index);
+ if (return_flags & PARROT_ARG_FLATTEN) {
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION,
+ "named flattened returns not yet implemented");
}
- default:
- Parrot_ex_throw_from_c_args(interp, NULL,
- EXCEPTION_INVALID_OPERATION, "invalid return type");
+ VTABLE_set_pmc_keyed_str(interp, named_return_list, return_name, return_item);
break;
+ }
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL,
+ EXCEPTION_INVALID_OPERATION, "invalid return type");
+ break;
}
}
@@ -2029,26 +2029,26 @@
/* Fill the named result. */
switch (PARROT_ARG_TYPE_MASK_MASK(result_flags)) {
- case PARROT_ARG_INTVAL:
- csr_fill_integer(interp, call_object, result_index,
+ case PARROT_ARG_INTVAL:
+ csr_fill_integer(interp, call_object, result_index,
VTABLE_get_integer_keyed_str(interp, named_return_list, result_name));
- break;
- case PARROT_ARG_FLOATVAL:
- csr_fill_number(interp, call_object, result_index,
+ break;
+ case PARROT_ARG_FLOATVAL:
+ csr_fill_number(interp, call_object, result_index,
VTABLE_get_number_keyed_str(interp, named_return_list, result_name));
- break;
- case PARROT_ARG_STRING:
- csr_fill_string(interp, call_object, result_index,
+ break;
+ case PARROT_ARG_STRING:
+ csr_fill_string(interp, call_object, result_index,
VTABLE_get_string_keyed_str(interp, named_return_list, result_name));
- break;
- case PARROT_ARG_PMC:
- csr_fill_pmc(interp, call_object, result_index,
+ break;
+ case PARROT_ARG_PMC:
+ csr_fill_pmc(interp, call_object, result_index,
VTABLE_get_pmc_keyed_str(interp, named_return_list, result_name));
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL,
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL,
EXCEPTION_INVALID_OPERATION, "invalid result type");
- break;
+ break;
}
VTABLE_delete_keyed_str(interp, named_return_list, result_name);
@@ -2345,9 +2345,9 @@
case 'S': flags = PARROT_ARG_STRING; set++; break;
case 'P': flags = PARROT_ARG_PMC; set++; break;
default:
- Parrot_ex_throw_from_c_args(interp, NULL,
- EXCEPTION_INVALID_OPERATION,
- "invalid signature string element %c!", *x);
+ Parrot_ex_throw_from_c_args(interp, NULL,
+ EXCEPTION_INVALID_OPERATION,
+ "invalid signature string element %c!", *x);
}
}
@@ -2984,20 +2984,20 @@
void *ptr = UNTAG_CELL(cell);
switch ((Call_bits_enum_t)CELL_TYPE_MASK(cell)) {
- case PARROT_ARG_INTVAL:
- *(INTVAL *)ptr = value;
- break;
- case PARROT_ARG_FLOATVAL:
- *(FLOATVAL *)ptr = value;
- break;
- case PARROT_ARG_STRING:
- *(STRING **)ptr = Parrot_str_from_int(interp, value);
- break;
- case PARROT_ARG_PMC:
- *(PMC **)ptr = get_integer_pmc(interp, value);
- break;
- default:
- PARROT_ASSERT(!"Impossible type");
+ case PARROT_ARG_INTVAL:
+ *(INTVAL *)ptr = value;
+ break;
+ case PARROT_ARG_FLOATVAL:
+ *(FLOATVAL *)ptr = value;
+ break;
+ case PARROT_ARG_STRING:
+ *(STRING **)ptr = Parrot_str_from_int(interp, value);
+ break;
+ case PARROT_ARG_PMC:
+ *(PMC **)ptr = get_integer_pmc(interp, value);
+ break;
+ default:
+ PARROT_ASSERT(!"Impossible type");
}
}
@@ -3009,20 +3009,20 @@
void *ptr = UNTAG_CELL(cell);
switch ((Call_bits_enum_t)CELL_TYPE_MASK(cell)) {
- case PARROT_ARG_INTVAL:
- *(INTVAL *)ptr = value;
- break;
- case PARROT_ARG_FLOATVAL:
- *(FLOATVAL *)ptr = value;
- break;
- case PARROT_ARG_STRING:
- *(STRING **)ptr = Parrot_str_from_num(interp, value);
- break;
- case PARROT_ARG_PMC:
- *(PMC **)ptr = get_number_pmc(interp, value);
- break;
- default:
- PARROT_ASSERT(!"Impossible type");
+ case PARROT_ARG_INTVAL:
+ *(INTVAL *)ptr = value;
+ break;
+ case PARROT_ARG_FLOATVAL:
+ *(FLOATVAL *)ptr = value;
+ break;
+ case PARROT_ARG_STRING:
+ *(STRING **)ptr = Parrot_str_from_num(interp, value);
+ break;
+ case PARROT_ARG_PMC:
+ *(PMC **)ptr = get_number_pmc(interp, value);
+ break;
+ default:
+ PARROT_ASSERT(!"Impossible type");
}
}
@@ -3034,22 +3034,22 @@
void *ptr = UNTAG_CELL(cell);
switch ((Call_bits_enum_t)CELL_TYPE_MASK(cell)) {
- case PARROT_ARG_INTVAL:
- *(INTVAL *)ptr = Parrot_str_to_int(interp, value);
- break;
- case PARROT_ARG_FLOATVAL:
- *(FLOATVAL *)ptr = Parrot_str_to_num(interp, value);
- break;
- case PARROT_ARG_STRING:
- *(STRING **)ptr = value;
- break;
- case PARROT_ARG_PMC:
- *(PMC **)ptr = STRING_IS_NULL(value) ?
+ case PARROT_ARG_INTVAL:
+ *(INTVAL *)ptr = Parrot_str_to_int(interp, value);
+ break;
+ case PARROT_ARG_FLOATVAL:
+ *(FLOATVAL *)ptr = Parrot_str_to_num(interp, value);
+ break;
+ case PARROT_ARG_STRING:
+ *(STRING **)ptr = value;
+ break;
+ case PARROT_ARG_PMC:
+ *(PMC **)ptr = STRING_IS_NULL(value) ?
PMCNULL :
get_string_pmc(interp, value);
- break;
- default:
- PARROT_ASSERT(!"Impossible type");
+ break;
+ default:
+ PARROT_ASSERT(!"Impossible type");
}
}
@@ -3061,20 +3061,20 @@
void *ptr = UNTAG_CELL(cell);
switch ((Call_bits_enum_t)CELL_TYPE_MASK(cell)) {
- case PARROT_ARG_INTVAL:
- *(INTVAL *)ptr = VTABLE_get_integer(interp, value);
- break;
- case PARROT_ARG_FLOATVAL:
- *(FLOATVAL *)ptr = VTABLE_get_number(interp, value);
- break;
- case PARROT_ARG_STRING:
- *(STRING **)ptr = VTABLE_get_string(interp, value);
- break;
- case PARROT_ARG_PMC:
- *(PMC **)ptr = value;
- break;
- default:
- PARROT_ASSERT(!"Impossible type");
+ case PARROT_ARG_INTVAL:
+ *(INTVAL *)ptr = VTABLE_get_integer(interp, value);
+ break;
+ case PARROT_ARG_FLOATVAL:
+ *(FLOATVAL *)ptr = VTABLE_get_number(interp, value);
+ break;
+ case PARROT_ARG_STRING:
+ *(STRING **)ptr = VTABLE_get_string(interp, value);
+ break;
+ case PARROT_ARG_PMC:
+ *(PMC **)ptr = value;
+ break;
+ default:
+ PARROT_ASSERT(!"Impossible type");
}
}
@@ -3173,28 +3173,28 @@
VTABLE_set_integer_native(interp, return_flags, return_flags_size + 1);
}
switch (Parrot_str_indexed(interp, type, 0)) {
- case 'I':
- VTABLE_set_integer_keyed_int(interp, return_flags, return_flags_size,
+ case 'I':
+ VTABLE_set_integer_keyed_int(interp, return_flags, return_flags_size,
PARROT_ARG_INTVAL);
- int_type = PARROT_ARG_INTVAL;
- break;
- case 'N':
- VTABLE_set_integer_keyed_int(interp, return_flags, return_flags_size,
+ int_type = PARROT_ARG_INTVAL;
+ break;
+ case 'N':
+ VTABLE_set_integer_keyed_int(interp, return_flags, return_flags_size,
PARROT_ARG_FLOATVAL);
- int_type = PARROT_ARG_FLOATVAL;
- break;
- case 'S':
- VTABLE_set_integer_keyed_int(interp, return_flags, return_flags_size,
+ int_type = PARROT_ARG_FLOATVAL;
+ break;
+ case 'S':
+ VTABLE_set_integer_keyed_int(interp, return_flags, return_flags_size,
PARROT_ARG_STRING);
- int_type = PARROT_ARG_STRING;
- break;
- case 'P':
- VTABLE_set_integer_keyed_int(interp, return_flags, return_flags_size,
+ int_type = PARROT_ARG_STRING;
+ break;
+ case 'P':
+ VTABLE_set_integer_keyed_int(interp, return_flags, return_flags_size,
PARROT_ARG_PMC);
- int_type = PARROT_ARG_PMC;
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL,
+ int_type = PARROT_ARG_PMC;
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL,
EXCEPTION_INVALID_OPERATION,
"invalid signature string element!");
}
Modified: trunk/src/call/ops.c
==============================================================================
--- trunk/src/call/ops.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/call/ops.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -68,31 +68,31 @@
#endif
{
new_runloop_jump_point(interp);
- reenter:
+ reenter:
interp->current_runloop->handler_start = NULL;
switch (setjmp(interp->current_runloop->resume)) {
- case 1:
- /* an exception was handled */
- if (STACKED_EXCEPTIONS)
- free_runloop_jump_point(interp);
+ case 1:
+ /* an exception was handled */
+ if (STACKED_EXCEPTIONS)
+ free_runloop_jump_point(interp);
- interp->current_runloop_level = our_runloop_level - 1;
- interp->current_runloop_id = old_runloop_id;
+ interp->current_runloop_level = our_runloop_level - 1;
+ interp->current_runloop_id = old_runloop_id;
#if RUNLOOP_TRACE
- fprintf(stderr, "[handled exception; back to loop %d, level %d]\n",
+ fprintf(stderr, "[handled exception; back to loop %d, level %d]\n",
interp->current_runloop_id, interp->current_runloop_level);
#endif
- return;
- case 2:
- /* Reenter the runloop from a exception thrown from C
- * with a pir handler */
- PARROT_ASSERT(interp->current_runloop->handler_start);
- offset = interp->current_runloop->handler_start - interp->code->base.data;
- /* Prevent incorrect reuse */
- goto reenter;
- default:
- break;
+ return;
+ case 2:
+ /* Reenter the runloop from a exception thrown from C
+ * with a pir handler */
+ PARROT_ASSERT(interp->current_runloop->handler_start);
+ offset = interp->current_runloop->handler_start - interp->code->base.data;
+ /* Prevent incorrect reuse */
+ goto reenter;
+ default:
+ break;
}
}
Modified: trunk/src/debug.c
==============================================================================
--- trunk/src/debug.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/debug.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -1509,20 +1509,20 @@
{
ASSERT_ARGS(condition_regtype)
switch (*cmd) {
- case 'i':
- case 'I':
- return PDB_cond_int;
- case 'n':
- case 'N':
- return PDB_cond_num;
- case 's':
- case 'S':
- return PDB_cond_str;
- case 'p':
- case 'P':
- return PDB_cond_pmc;
- default:
- return 0;
+ case 'i':
+ case 'I':
+ return PDB_cond_int;
+ case 'n':
+ case 'N':
+ return PDB_cond_num;
+ case 's':
+ case 'S':
+ return PDB_cond_str;
+ case 'p':
+ case 'P':
+ return PDB_cond_pmc;
+ default:
+ return 0;
}
}
@@ -1575,40 +1575,41 @@
/* Now the condition */
command = skip_whitespace(command);
switch (*command) {
- case '>':
- if (*(command + 1) == '=')
- cond_type = PDB_cond_ge;
- else
- cond_type = PDB_cond_gt;
- break;
- case '<':
- if (*(command + 1) == '=')
- cond_type = PDB_cond_le;
- else
- cond_type = PDB_cond_lt;
- break;
- case '=':
- if (*(command + 1) == '=')
- cond_type = PDB_cond_eq;
- else
- goto INV_COND;
- break;
- case '!':
- if (*(command + 1) == '=')
- cond_type = PDB_cond_ne;
- else
- goto INV_COND;
- break;
- case '\0':
- if (cond_argleft != PDB_cond_str && cond_argleft != PDB_cond_pmc) {
- Parrot_io_eprintf(interp->pdb->debugger, "Invalid null condition\n");
- return NULL;
- }
- cond_type = PDB_cond_notnull;
- break;
- default:
-INV_COND: Parrot_io_eprintf(interp->pdb->debugger, "Invalid condition\n");
+ case '>':
+ if (*(command + 1) == '=')
+ cond_type = PDB_cond_ge;
+ else
+ cond_type = PDB_cond_gt;
+ break;
+ case '<':
+ if (*(command + 1) == '=')
+ cond_type = PDB_cond_le;
+ else
+ cond_type = PDB_cond_lt;
+ break;
+ case '=':
+ if (*(command + 1) == '=')
+ cond_type = PDB_cond_eq;
+ else
+ goto INV_COND;
+ break;
+ case '!':
+ if (*(command + 1) == '=')
+ cond_type = PDB_cond_ne;
+ else
+ goto INV_COND;
+ break;
+ case '\0':
+ if (cond_argleft != PDB_cond_str && cond_argleft != PDB_cond_pmc) {
+ Parrot_io_eprintf(interp->pdb->debugger, "Invalid null condition\n");
return NULL;
+ }
+ cond_type = PDB_cond_notnull;
+ break;
+ default:
+ INV_COND:
+ Parrot_io_eprintf(interp->pdb->debugger, "Invalid condition\n");
+ return NULL;
}
/* if there's an '=', skip it */
@@ -2427,37 +2428,37 @@
for (; string < end; string++) {
switch (*string) {
- case '\0':
- *(fill++) = '\\';
- *(fill++) = '0';
- break;
- case '\n':
- *(fill++) = '\\';
- *(fill++) = 'n';
- break;
- case '\r':
- *(fill++) = '\\';
- *(fill++) = 'r';
- break;
- case '\t':
- *(fill++) = '\\';
- *(fill++) = 't';
- break;
- case '\a':
- *(fill++) = '\\';
- *(fill++) = 'a';
- break;
- case '\\':
- *(fill++) = '\\';
- *(fill++) = '\\';
- break;
- case '"':
- *(fill++) = '\\';
- *(fill++) = '"';
- break;
- default:
- *(fill++) = *string;
- break;
+ case '\0':
+ *(fill++) = '\\';
+ *(fill++) = '0';
+ break;
+ case '\n':
+ *(fill++) = '\\';
+ *(fill++) = 'n';
+ break;
+ case '\r':
+ *(fill++) = '\\';
+ *(fill++) = 'r';
+ break;
+ case '\t':
+ *(fill++) = '\\';
+ *(fill++) = 't';
+ break;
+ case '\a':
+ *(fill++) = '\\';
+ *(fill++) = 'a';
+ break;
+ case '\\':
+ *(fill++) = '\\';
+ *(fill++) = '\\';
+ break;
+ case '"':
+ *(fill++) = '\\';
+ *(fill++) = '"';
+ break;
+ default:
+ *(fill++) = *string;
+ break;
}
}
@@ -2490,23 +2491,23 @@
int i;
switch (string[1]) {
- case 'n':
- *string = '\n';
- break;
- case 'r':
- *string = '\r';
- break;
- case 't':
- *string = '\t';
- break;
- case 'a':
- *string = '\a';
- break;
- case '\\':
- *string = '\\';
- break;
- default:
- continue;
+ case 'n':
+ *string = '\n';
+ break;
+ case 'r':
+ *string = '\r';
+ break;
+ case 't':
+ *string = '\t';
+ break;
+ case 'a':
+ *string = '\a';
+ break;
+ case '\\':
+ *string = '\\';
+ break;
+ default:
+ continue;
}
fill = string;
@@ -2564,19 +2565,19 @@
PARROT_ASSERT(size + 2 < space);
switch (info->types[j - 1]) {
- case PARROT_ARG_I:
+ case PARROT_ARG_I:
dest[size++] = 'I';
goto INTEGER;
- case PARROT_ARG_N:
+ case PARROT_ARG_N:
dest[size++] = 'N';
goto INTEGER;
- case PARROT_ARG_S:
+ case PARROT_ARG_S:
dest[size++] = 'S';
goto INTEGER;
- case PARROT_ARG_P:
+ case PARROT_ARG_P:
dest[size++] = 'P';
goto INTEGER;
- case PARROT_ARG_IC:
+ case PARROT_ARG_IC:
/* If the opcode jumps and this is the last argument,
that means this is a label */
if ((j == info->op_count - 1) &&
@@ -2607,16 +2608,16 @@
size += sprintf(&dest[size], INTVAL_FMT, i);
break;
- case PARROT_ARG_NC:
+ case PARROT_ARG_NC:
{
- /* Convert the float to a string */
- const FLOATVAL f = interp->code->const_table->constants[op[j]]->u.number;
- Parrot_snprintf(interp, buf, sizeof (buf), FLOATVAL_FMT, f);
- strcpy(&dest[size], buf);
- size += strlen(buf);
+ /* Convert the float to a string */
+ const FLOATVAL f = interp->code->const_table->constants[op[j]]->u.number;
+ Parrot_snprintf(interp, buf, sizeof (buf), FLOATVAL_FMT, f);
+ strcpy(&dest[size], buf);
+ size += strlen(buf);
}
break;
- case PARROT_ARG_SC:
+ case PARROT_ARG_SC:
dest[size++] = '"';
if (interp->code->const_table->constants[op[j]]-> u.string->strlen) {
char * const unescaped =
@@ -2634,100 +2635,100 @@
}
dest[size++] = '"';
break;
- case PARROT_ARG_PC:
+ case PARROT_ARG_PC:
Parrot_snprintf(interp, buf, sizeof (buf), "PMC_CONST(%d)", op[j]);
strcpy(&dest[size], buf);
size += strlen(buf);
break;
- case PARROT_ARG_K:
+ case PARROT_ARG_K:
dest[size - 1] = '[';
Parrot_snprintf(interp, buf, sizeof (buf), "P" INTVAL_FMT, op[j]);
strcpy(&dest[size], buf);
size += strlen(buf);
dest[size++] = ']';
break;
- case PARROT_ARG_KC:
+ case PARROT_ARG_KC:
{
- PMC * k = interp->code->const_table->constants[op[j]]->u.key;
- dest[size - 1] = '[';
- while (k) {
- switch (PObj_get_FLAGS(k)) {
- case 0:
- break;
- case KEY_integer_FLAG:
- Parrot_snprintf(interp, buf, sizeof (buf),
+ PMC * k = interp->code->const_table->constants[op[j]]->u.key;
+ dest[size - 1] = '[';
+ while (k) {
+ switch (PObj_get_FLAGS(k)) {
+ case 0:
+ break;
+ case KEY_integer_FLAG:
+ Parrot_snprintf(interp, buf, sizeof (buf),
INTVAL_FMT, VTABLE_get_integer(interp, k));
- strcpy(&dest[size], buf);
- size += strlen(buf);
- break;
- case KEY_number_FLAG:
- Parrot_snprintf(interp, buf, sizeof (buf),
+ strcpy(&dest[size], buf);
+ size += strlen(buf);
+ break;
+ case KEY_number_FLAG:
+ Parrot_snprintf(interp, buf, sizeof (buf),
FLOATVAL_FMT, VTABLE_get_number(interp, k));
- strcpy(&dest[size], buf);
- size += strlen(buf);
- break;
- case KEY_string_FLAG:
- dest[size++] = '"';
- {
- char * const temp = Parrot_str_to_cstring(interp,
- VTABLE_get_string(interp, k));
- strcpy(&dest[size], temp);
- Parrot_str_free_cstring(temp);
- }
- size += Parrot_str_byte_length(interp,
- VTABLE_get_string(interp, (k)));
- dest[size++] = '"';
- break;
- case KEY_integer_FLAG|KEY_register_FLAG:
- Parrot_snprintf(interp, buf, sizeof (buf),
+ strcpy(&dest[size], buf);
+ size += strlen(buf);
+ break;
+ case KEY_string_FLAG:
+ dest[size++] = '"';
+ {
+ char * const temp = Parrot_str_to_cstring(interp,
+ VTABLE_get_string(interp, k));
+ strcpy(&dest[size], temp);
+ Parrot_str_free_cstring(temp);
+ }
+ size += Parrot_str_byte_length(interp,
+ VTABLE_get_string(interp, (k)));
+ dest[size++] = '"';
+ break;
+ case KEY_integer_FLAG|KEY_register_FLAG:
+ Parrot_snprintf(interp, buf, sizeof (buf),
"I" INTVAL_FMT, VTABLE_get_integer(interp, k));
- strcpy(&dest[size], buf);
- size += strlen(buf);
- break;
- case KEY_number_FLAG|KEY_register_FLAG:
- Parrot_snprintf(interp, buf, sizeof (buf),
+ strcpy(&dest[size], buf);
+ size += strlen(buf);
+ break;
+ case KEY_number_FLAG|KEY_register_FLAG:
+ Parrot_snprintf(interp, buf, sizeof (buf),
"N" INTVAL_FMT, VTABLE_get_integer(interp, k));
- strcpy(&dest[size], buf);
- size += strlen(buf);
- break;
- case KEY_string_FLAG|KEY_register_FLAG:
- Parrot_snprintf(interp, buf, sizeof (buf),
+ strcpy(&dest[size], buf);
+ size += strlen(buf);
+ break;
+ case KEY_string_FLAG|KEY_register_FLAG:
+ Parrot_snprintf(interp, buf, sizeof (buf),
"S" INTVAL_FMT, VTABLE_get_integer(interp, k));
- strcpy(&dest[size], buf);
- size += strlen(buf);
- break;
- case KEY_pmc_FLAG|KEY_register_FLAG:
- Parrot_snprintf(interp, buf, sizeof (buf),
+ strcpy(&dest[size], buf);
+ size += strlen(buf);
+ break;
+ case KEY_pmc_FLAG|KEY_register_FLAG:
+ Parrot_snprintf(interp, buf, sizeof (buf),
"P" INTVAL_FMT, VTABLE_get_integer(interp, k));
- strcpy(&dest[size], buf);
- size += strlen(buf);
- break;
- default:
- dest[size++] = '?';
- break;
+ strcpy(&dest[size], buf);
+ size += strlen(buf);
+ break;
+ default:
+ dest[size++] = '?';
+ break;
+ }
+ GETATTR_Key_next_key(interp, k, k);
+ if (k)
+ dest[size++] = ';';
}
- GETATTR_Key_next_key(interp, k, k);
- if (k)
- dest[size++] = ';';
- }
- dest[size++] = ']';
+ dest[size++] = ']';
}
break;
- case PARROT_ARG_KI:
+ case PARROT_ARG_KI:
dest[size - 1] = '[';
Parrot_snprintf(interp, buf, sizeof (buf), "I" INTVAL_FMT, op[j]);
strcpy(&dest[size], buf);
size += strlen(buf);
dest[size++] = ']';
break;
- case PARROT_ARG_KIC:
+ case PARROT_ARG_KIC:
dest[size - 1] = '[';
Parrot_snprintf(interp, buf, sizeof (buf), INTVAL_FMT, op[j]);
strcpy(&dest[size], buf);
size += strlen(buf);
dest[size++] = ']';
break;
- default:
+ default:
Parrot_ex_throw_from_c_args(interp, NULL, 1, "Unknown opcode type");
}
@@ -3216,22 +3217,22 @@
register_num = get_ulong(&command, 0);
switch (reg_type_id) {
- case 'I':
- reg_type = REGNO_INT;
- break;
- case 'N':
- reg_type = REGNO_NUM;
- break;
- case 'S':
- reg_type = REGNO_STR;
- break;
- case 'P':
- reg_type = REGNO_PMC;
- Parrot_io_eprintf(debugger, "Assigning to PMCs is not currently supported\n");
- return;
- default:
- Parrot_io_eprintf(debugger, "Invalid register type %c\n", reg_type_id);
- return;
+ case 'I':
+ reg_type = REGNO_INT;
+ break;
+ case 'N':
+ reg_type = REGNO_NUM;
+ break;
+ case 'S':
+ reg_type = REGNO_STR;
+ break;
+ case 'P':
+ reg_type = REGNO_PMC;
+ Parrot_io_eprintf(debugger, "Assigning to PMCs is not currently supported\n");
+ return;
+ default:
+ Parrot_io_eprintf(debugger, "Invalid register type %c\n", reg_type_id);
+ return;
}
if (register_num >= Parrot_pcc_get_regs_used(debugee,
CURRENT_CONTEXT(debugee), reg_type)) {
@@ -3239,16 +3240,17 @@
return;
}
switch (reg_type) {
- case REGNO_INT:
- IREG(register_num) = get_ulong(&command, 0);
- break;
- case REGNO_NUM:
- NREG(register_num) = atof(command);
- break;
- case REGNO_STR:
- SREG(register_num) = Parrot_str_new(debugee, command, strlen(command));
- break;
- default: ; /* Must never come here */
+ case REGNO_INT:
+ IREG(register_num) = get_ulong(&command, 0);
+ break;
+ case REGNO_NUM:
+ NREG(register_num) = atof(command);
+ break;
+ case REGNO_STR:
+ SREG(register_num) = Parrot_str_new(debugee, command, strlen(command));
+ break;
+ default:
+ ; /* Must never come here */
}
Parrot_io_eprintf(debugger, "\n %c%u = ", reg_type_id, register_num);
Parrot_io_eprintf(debugger, "%Ss\n", GDB_print_reg(debugee, reg_type, register_num));
@@ -3643,25 +3645,25 @@
if (n >= 0 && (UINTVAL)n < Parrot_pcc_get_regs_used(interp, CURRENT_CONTEXT(interp), t)) {
switch (t) {
- case REGNO_INT:
- return Parrot_str_from_int(interp, IREG(n));
- case REGNO_NUM:
- return Parrot_str_from_num(interp, NREG(n));
- case REGNO_STR:
- /* This hack is needed because we occasionally are told
- that we have string registers when we actually don't */
- string = (char *) SREG(n);
-
- if (string == '\0')
- return Parrot_str_new(interp, "", 0);
- else
- return SREG(n);
- case REGNO_PMC:
- /* prints directly */
- trace_pmc_dump(interp, PREG(n));
+ case REGNO_INT:
+ return Parrot_str_from_int(interp, IREG(n));
+ case REGNO_NUM:
+ return Parrot_str_from_num(interp, NREG(n));
+ case REGNO_STR:
+ /* This hack is needed because we occasionally are told
+ that we have string registers when we actually don't */
+ string = (char *) SREG(n);
+
+ if (string == '\0')
return Parrot_str_new(interp, "", 0);
- default:
- break;
+ else
+ return SREG(n);
+ case REGNO_PMC:
+ /* prints directly */
+ trace_pmc_dump(interp, PREG(n));
+ return Parrot_str_new(interp, "", 0);
+ default:
+ break;
}
}
return Parrot_str_new(interp, "no such register", 0);
Modified: trunk/src/embed.c
==============================================================================
--- trunk/src/embed.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/embed.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -143,12 +143,12 @@
Interp_flags_SET(interp, flag);
switch (flag) {
- case PARROT_BOUNDS_FLAG:
- case PARROT_PROFILE_FLAG:
- Parrot_runcore_switch(interp, Parrot_str_new_constant(interp, "slow"));
- break;
- default:
- break;
+ case PARROT_BOUNDS_FLAG:
+ case PARROT_PROFILE_FLAG:
+ Parrot_runcore_switch(interp, Parrot_str_new_constant(interp, "slow"));
+ break;
+ default:
+ break;
}
}
@@ -335,35 +335,35 @@
Parrot_set_run_core(PARROT_INTERP, Parrot_Run_core_t core)
{
switch (core) {
- case PARROT_SLOW_CORE:
- Parrot_runcore_switch(interp, Parrot_str_new_constant(interp, "slow"));
- break;
- case PARROT_FAST_CORE:
- Parrot_runcore_switch(interp, Parrot_str_new_constant(interp, "fast"));
- break;
- case PARROT_SWITCH_CORE:
- Parrot_runcore_switch(interp, Parrot_str_new_constant(interp, "switch"));
- break;
- case PARROT_CGP_CORE:
- Parrot_runcore_switch(interp, Parrot_str_new_constant(interp, "cgp"));
- break;
- case PARROT_CGOTO_CORE:
- Parrot_runcore_switch(interp, Parrot_str_new_constant(interp, "cgoto"));
- break;
- case PARROT_EXEC_CORE:
- Parrot_runcore_switch(interp, Parrot_str_new_constant(interp, "exec"));
- break;
- case PARROT_GC_DEBUG_CORE:
- Parrot_runcore_switch(interp, Parrot_str_new_constant(interp, "gc_debug"));
- break;
- case PARROT_DEBUGGER_CORE:
- Parrot_runcore_switch(interp, Parrot_str_new_constant(interp, "debugger"));
- break;
- case PARROT_PROFILING_CORE:
- Parrot_runcore_switch(interp, Parrot_str_new_constant(interp, "profiling"));
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
+ case PARROT_SLOW_CORE:
+ Parrot_runcore_switch(interp, Parrot_str_new_constant(interp, "slow"));
+ break;
+ case PARROT_FAST_CORE:
+ Parrot_runcore_switch(interp, Parrot_str_new_constant(interp, "fast"));
+ break;
+ case PARROT_SWITCH_CORE:
+ Parrot_runcore_switch(interp, Parrot_str_new_constant(interp, "switch"));
+ break;
+ case PARROT_CGP_CORE:
+ Parrot_runcore_switch(interp, Parrot_str_new_constant(interp, "cgp"));
+ break;
+ case PARROT_CGOTO_CORE:
+ Parrot_runcore_switch(interp, Parrot_str_new_constant(interp, "cgoto"));
+ break;
+ case PARROT_EXEC_CORE:
+ Parrot_runcore_switch(interp, Parrot_str_new_constant(interp, "exec"));
+ break;
+ case PARROT_GC_DEBUG_CORE:
+ Parrot_runcore_switch(interp, Parrot_str_new_constant(interp, "gc_debug"));
+ break;
+ case PARROT_DEBUGGER_CORE:
+ Parrot_runcore_switch(interp, Parrot_str_new_constant(interp, "debugger"));
+ break;
+ case PARROT_PROFILING_CORE:
+ Parrot_runcore_switch(interp, Parrot_str_new_constant(interp, "profiling"));
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
"Invalid runcore requested\n");
}
}
@@ -891,31 +891,33 @@
const PackFile_Constant * const c = interp->code->const_table->constants[i];
switch (c->type) {
- case PFC_NUMBER:
- Parrot_io_printf(interp, "PMC_CONST(%d): %f\n", i, c->u.number);
- break;
- case PFC_STRING:
- Parrot_io_printf(interp, "PMC_CONST(%d): %S\n", i, c->u.string);
- break;
- case PFC_KEY:
- Parrot_io_printf(interp, "PMC_CONST(%d): ", i);
- /* XXX */
- /* Parrot_print_p(interp, c->u.key); */
- Parrot_io_printf(interp, "(PMC constant)");
- Parrot_io_printf(interp, "\n");
- break;
- case PFC_PMC: {
+ case PFC_NUMBER:
+ Parrot_io_printf(interp, "PMC_CONST(%d): %f\n", i, c->u.number);
+ break;
+ case PFC_STRING:
+ Parrot_io_printf(interp, "PMC_CONST(%d): %S\n", i, c->u.string);
+ break;
+ case PFC_KEY:
+ Parrot_io_printf(interp, "PMC_CONST(%d): ", i);
+ /* XXX */
+ /* Parrot_print_p(interp, c->u.key); */
+ Parrot_io_printf(interp, "(PMC constant)");
+ Parrot_io_printf(interp, "\n");
+ break;
+ case PFC_PMC:
+ {
Parrot_io_printf(interp, "PMC_CONST(%d): ", i);
switch (c->u.key->vtable->base_type) {
/* each PBC file has a ParrotInterpreter, but it can't
* stringify by itself */
- case enum_class_ParrotInterpreter:
- Parrot_io_printf(interp, "'ParrotInterpreter'");
- break;
+ case enum_class_ParrotInterpreter:
+ Parrot_io_printf(interp, "'ParrotInterpreter'");
+ break;
/* FixedIntegerArrays used for signatures, handy to print */
- case enum_class_FixedIntegerArray: {
+ case enum_class_FixedIntegerArray:
+ {
INTVAL n = VTABLE_elements(interp, c->u.key);
INTVAL i;
Parrot_io_printf(interp, "[");
@@ -929,32 +931,32 @@
Parrot_io_printf(interp, "]");
break;
}
- case enum_class_NameSpace:
- case enum_class_String:
- case enum_class_Key:
- case enum_class_ResizableStringArray:
- {
- /*Parrot_print_p(interp, c->u.key);*/
- STRING * const s = VTABLE_get_string(interp, c->u.key);
- if (s)
- Parrot_io_printf(interp, "%Ss", s);
- break;
- }
- case enum_class_Sub:
- Parrot_io_printf(interp, "%S", VTABLE_get_string(interp, c->u.key));
- break;
- default:
- Parrot_io_printf(interp, "(PMC constant)");
+ case enum_class_NameSpace:
+ case enum_class_String:
+ case enum_class_Key:
+ case enum_class_ResizableStringArray:
+ {
+ /*Parrot_print_p(interp, c->u.key);*/
+ STRING * const s = VTABLE_get_string(interp, c->u.key);
+ if (s)
+ Parrot_io_printf(interp, "%Ss", s);
break;
+ }
+ case enum_class_Sub:
+ Parrot_io_printf(interp, "%S", VTABLE_get_string(interp, c->u.key));
+ break;
+ default:
+ Parrot_io_printf(interp, "(PMC constant)");
+ break;
}
Parrot_io_printf(interp, "\n");
break;
}
- default:
- Parrot_io_printf(interp, "wrong constant type in constant table!\n");
- /* XXX throw an exception? Is it worth the trouble? */
- break;
+ default:
+ Parrot_io_printf(interp, "wrong constant type in constant table!\n");
+ /* XXX throw an exception? Is it worth the trouble? */
+ break;
}
}
Modified: trunk/src/events.c
==============================================================================
--- trunk/src/events.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/events.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -244,14 +244,14 @@
{
ASSERT_ARGS(sig_handler)
switch (signum) {
- case SIGINT:
- sig_int = 1;
- break;
- case SIGHUP:
- sig_hup = 1;
- break;
- default:
- break;
+ case SIGINT:
+ sig_int = 1;
+ break;
+ case SIGHUP:
+ sig_hup = 1;
+ break;
+ default:
+ break;
}
}
@@ -477,21 +477,21 @@
ev->interp = interp;
entry->data = ev;
switch (ev->type) {
- case EVENT_TYPE_TIMER:
- case EVENT_TYPE_SLEEP:
- entry->type = QUEUE_ENTRY_TYPE_TIMED_EVENT;
- insert_entry(event_queue, entry);
- break;
- case EVENT_TYPE_CALL_BACK:
- case EVENT_TYPE_SIGNAL:
- case EVENT_TYPE_IO:
- entry->type = QUEUE_ENTRY_TYPE_EVENT;
- unshift_entry(event_queue, entry);
- break;
- default:
- entry->type = QUEUE_ENTRY_TYPE_EVENT;
- push_entry(event_queue, entry);
- break;
+ case EVENT_TYPE_TIMER:
+ case EVENT_TYPE_SLEEP:
+ entry->type = QUEUE_ENTRY_TYPE_TIMED_EVENT;
+ insert_entry(event_queue, entry);
+ break;
+ case EVENT_TYPE_CALL_BACK:
+ case EVENT_TYPE_SIGNAL:
+ case EVENT_TYPE_IO:
+ entry->type = QUEUE_ENTRY_TYPE_EVENT;
+ unshift_entry(event_queue, entry);
+ break;
+ default:
+ entry->type = QUEUE_ENTRY_TYPE_EVENT;
+ push_entry(event_queue, entry);
+ break;
}
}
@@ -722,13 +722,13 @@
* in front or at the end of the queue
*/
switch (event->type) {
- case EVENT_TYPE_CALL_BACK:
- case EVENT_TYPE_SIGNAL:
- unshift_entry(interp->task_queue, entry);
- break;
- default:
- push_entry(interp->task_queue, entry);
- break;
+ case EVENT_TYPE_CALL_BACK:
+ case EVENT_TYPE_SIGNAL:
+ unshift_entry(interp->task_queue, entry);
+ break;
+ default:
+ push_entry(interp->task_queue, entry);
+ break;
}
}
@@ -749,52 +749,52 @@
parrot_event * const event = (parrot_event *)entry->data;
switch (event->type) {
- case EVENT_TYPE_SIGNAL:
- edebug((stderr, "broadcast signal\n"));
- /*
- * we don't have special signal handlers in usercode yet
- * e.g.:
- * install handler like exception handler *and*
- * set a interpreter flag, that a handler exists
- * we then could examine that flag (after LOCKing it)
- * and dispatch the exception to all interpreters that
- * handle it
- * Finally, we send the first (main) interpreter that signal
- *
- * For now just send to all.
- *
- */
- switch (event->u.signal) {
- case SIGHUP:
- case SIGINT:
- {
- if (n_interpreters) {
- size_t i;
- LOCK(interpreter_array_mutex);
- for (i = 1; i < n_interpreters; ++i) {
- Interp *interp;
- edebug((stderr, "deliver SIGINT to %d\n", i));
- interp = interpreter_array[i];
- if (interp)
- Parrot_schedule_interp_qentry(interp,
+ case EVENT_TYPE_SIGNAL:
+ edebug((stderr, "broadcast signal\n"));
+ /*
+ * we don't have special signal handlers in usercode yet
+ * e.g.:
+ * install handler like exception handler *and*
+ * set a interpreter flag, that a handler exists
+ * we then could examine that flag (after LOCKing it)
+ * and dispatch the exception to all interpreters that
+ * handle it
+ * Finally, we send the first (main) interpreter that signal
+ *
+ * For now just send to all.
+ *
+ */
+ switch (event->u.signal) {
+ case SIGHUP:
+ case SIGINT:
+ {
+ if (n_interpreters) {
+ size_t i;
+ LOCK(interpreter_array_mutex);
+ for (i = 1; i < n_interpreters; ++i) {
+ Interp *interp;
+ edebug((stderr, "deliver SIGINT to %d\n", i));
+ interp = interpreter_array[i];
+ if (interp)
+ Parrot_schedule_interp_qentry(interp,
dup_entry(entry));
- }
- UNLOCK(interpreter_array_mutex);
- }
- Parrot_schedule_interp_qentry(interpreter_array[0], entry);
- edebug((stderr, "deliver SIGINT to 0\n"));
}
- break;
- default:
- mem_sys_free(entry);
- mem_sys_free(event);
+ UNLOCK(interpreter_array_mutex);
+ }
+ Parrot_schedule_interp_qentry(interpreter_array[0], entry);
+ edebug((stderr, "deliver SIGINT to 0\n"));
}
break;
- default:
+ default:
mem_sys_free(entry);
mem_sys_free(event);
- exit_fatal(1, "Unknown event to broadcast");
- break;
+ }
+ break;
+ default:
+ mem_sys_free(entry);
+ mem_sys_free(event);
+ exit_fatal(1, "Unknown event to broadcast");
+ break;
}
}
@@ -1154,37 +1154,37 @@
parrot_event *event = NULL;
switch (entry->type) {
- case QUEUE_ENTRY_TYPE_EVENT:
- entry = nosync_pop_entry(event_q);
- event = (parrot_event *)entry->data;
- break;
+ case QUEUE_ENTRY_TYPE_EVENT:
+ entry = nosync_pop_entry(event_q);
+ event = (parrot_event *)entry->data;
+ break;
+
+ case QUEUE_ENTRY_TYPE_TIMED_EVENT:
+ event = (parrot_event *)entry->data;
+ now = Parrot_floatval_time();
- case QUEUE_ENTRY_TYPE_TIMED_EVENT:
- event = (parrot_event *)entry->data;
- now = Parrot_floatval_time();
-
- /*
- * if the timer_event isn't due yet, ignore the event
- * (we were signalled on insert of the event)
- * wait until we get at it again when time has elapsed
- */
- if (now < event->u.timer_event.abs_time)
- return 1;
- entry = nosync_pop_entry(event_q);
-
- /* if event is repeated dup and reinsert it */
-
- if (event->u.timer_event.interval) {
- if (event->u.timer_event.repeat) {
- if (event->u.timer_event.repeat != -1)
- event->u.timer_event.repeat--;
- nosync_insert_entry(event_q,
+ /*
+ * if the timer_event isn't due yet, ignore the event
+ * (we were signalled on insert of the event)
+ * wait until we get at it again when time has elapsed
+ */
+ if (now < event->u.timer_event.abs_time)
+ return 1;
+ entry = nosync_pop_entry(event_q);
+
+ /* if event is repeated dup and reinsert it */
+
+ if (event->u.timer_event.interval) {
+ if (event->u.timer_event.repeat) {
+ if (event->u.timer_event.repeat != -1)
+ event->u.timer_event.repeat--;
+ nosync_insert_entry(event_q,
dup_entry_interval(entry, now));
- }
}
- break;
- default:
- exit_fatal(1, "Unknown queue entry");
+ }
+ break;
+ default:
+ exit_fatal(1, "Unknown queue entry");
}
PARROT_ASSERT(event);
if (event->type == EVENT_TYPE_NONE) {
@@ -1417,24 +1417,24 @@
const int exit_code = -event->u.signal;
switch (event->u.signal) {
- case SIGINT:
- case SIGHUP:
- /*
- * SIGINT is silent, if no exception handler is
- * installed: set severity to EXCEPT_exit
- */
- {
- STRING * const message = CONST_STRING(interp, "Caught signal.");
- PMC *exception = Parrot_ex_build_exception(interp,
+ case SIGINT:
+ case SIGHUP:
+ /*
+ * SIGINT is silent, if no exception handler is
+ * installed: set severity to EXCEPT_exit
+ */
+ {
+ STRING * const message = CONST_STRING(interp, "Caught signal.");
+ PMC *exception = Parrot_ex_build_exception(interp,
EXCEPT_exit, exit_code, message);
- Parrot_ex_throw_from_c(interp, exception);
- }
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, exit_code,
+ Parrot_ex_throw_from_c(interp, exception);
+ }
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, exit_code,
"Caught signal.");
- break;
+ break;
}
}
@@ -1459,43 +1459,43 @@
ASSERT_ARGS(do_event)
edebug((stderr, "do_event %s\n", et(event)));
switch (event->type) {
- case EVENT_TYPE_TERMINATE:
- next = NULL; /* this will terminate the run loop */
- break;
- case EVENT_TYPE_SIGNAL:
- interp->sleeping = 0;
- /* generate exception */
- event_to_exception(interp, event);
- /* not reached - will longjmp */
- break;
- case EVENT_TYPE_TIMER:
- /* run ops, save registers */
- Parrot_pcc_invoke_sub_from_c_args(interp,
+ case EVENT_TYPE_TERMINATE:
+ next = NULL; /* this will terminate the run loop */
+ break;
+ case EVENT_TYPE_SIGNAL:
+ interp->sleeping = 0;
+ /* generate exception */
+ event_to_exception(interp, event);
+ /* not reached - will longjmp */
+ break;
+ case EVENT_TYPE_TIMER:
+ /* run ops, save registers */
+ Parrot_pcc_invoke_sub_from_c_args(interp,
event->u.timer_event.sub, "->");
- break;
- case EVENT_TYPE_CALL_BACK:
- edebug((stderr, "starting user cb\n"));
- Parrot_run_callback(interp, event->u.call_back.cbi,
+ break;
+ case EVENT_TYPE_CALL_BACK:
+ edebug((stderr, "starting user cb\n"));
+ Parrot_run_callback(interp, event->u.call_back.cbi,
event->u.call_back.external_data);
- break;
- case EVENT_TYPE_IO:
- edebug((stderr, "starting io handler\n"));
- Parrot_pcc_invoke_sub_from_c_args(interp,
+ break;
+ case EVENT_TYPE_IO:
+ edebug((stderr, "starting io handler\n"));
+ Parrot_pcc_invoke_sub_from_c_args(interp,
event->u.io_event.handler,
"PP->",
event->u.io_event.pio,
event->u.io_event.user_data);
- break;
- case EVENT_TYPE_SLEEP:
- interp->sleeping = 0;
- break;
- case EVENT_TYPE_SUSPEND_FOR_GC:
- edebug((stderr, "suspend for gc\n"));
- pt_suspend_self_for_gc(interp);
- break;
- default:
- fprintf(stderr, "Unhandled event type %d\n", (int)event->type);
- break;
+ break;
+ case EVENT_TYPE_SLEEP:
+ interp->sleeping = 0;
+ break;
+ case EVENT_TYPE_SUSPEND_FOR_GC:
+ edebug((stderr, "suspend for gc\n"));
+ pt_suspend_self_for_gc(interp);
+ break;
+ default:
+ fprintf(stderr, "Unhandled event type %d\n", (int)event->type);
+ break;
}
mem_sys_free(event);
return next;
Modified: trunk/src/frame_builder.c
==============================================================================
--- trunk/src/frame_builder.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/frame_builder.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -139,22 +139,22 @@
int scale_byte;
switch (scale) {
- case 1:
- scale_byte = emit_Scale_1;
- break;
- case 2:
- scale_byte = emit_Scale_2;
- break;
- case 4:
- scale_byte = emit_Scale_4;
- break;
- case 8:
- scale_byte = emit_Scale_8;
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_JIT_ERROR,
+ case 1:
+ scale_byte = emit_Scale_1;
+ break;
+ case 2:
+ scale_byte = emit_Scale_2;
+ break;
+ case 4:
+ scale_byte = emit_Scale_4;
+ break;
+ case 8:
+ scale_byte = emit_Scale_8;
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_JIT_ERROR,
"Invalid scale factor %d\n", scale);
- return;
+ return;
}
*pc = (char)(scale_byte | (i == emit_None ? emit_Index_None : emit_reg_Index(i)) |
@@ -258,16 +258,16 @@
size_t stack_size = 0;
while (*sig) {
switch (*sig) {
- case 't':
- (*strings)++;
- stack_size +=4;
- break;
- case 'd':
- stack_size +=8;
- break;
- default:
- stack_size +=4;
- break;
+ case 't':
+ (*strings)++;
+ stack_size +=4;
+ break;
+ case 'd':
+ stack_size +=8;
+ break;
+ default:
+ stack_size +=4;
+ break;
}
sig++;
}
@@ -359,104 +359,104 @@
emitm_movl_i_m(pc, arg_count, emit_EBP, 0, 1, temp_calls_offset + 8);
switch (*sig) {
- case '0': /* null ptr or such - doesn't consume a reg */
- jit_emit_bxor_rr_i(interp, pc, emit_EAX, emit_EAX);
- emitm_movl_m_r(interp, pc, emit_EAX, emit_EBP, 0, 1, args_offset);
- break;
- case 'f':
- /* FIXME (TT #1325) emitm_call_cfunc(pc, get_nci_N); */
- emitm_fstps(interp, pc, emit_EBP, 0, 1, args_offset);
- break;
- case 'N':
- case 'd':
- /* FIXME (TT #1325) emitm_call_cfunc(pc, get_nci_N); */
- emitm_fstpl(interp, pc, emit_EBP, 0, 1, args_offset);
- args_offset += 4;
- break;
- case 'I': /* INTVAL */
- case 'l': /* long */
- case 'i': /* int */
- /* FIXME (TT #1325) emitm_call_cfunc(pc, get_nci_I); */
- emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, args_offset);
- break;
- case 't': /* string, pass a cstring */
- /* FIXME (TT #1325) emitm_call_cfunc(pc, get_nci_S); */
- emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 4);
- emitm_call_cfunc(pc, string_to_cstring_nullable);
-
- emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, args_offset);
- /* save off temporary allocation address */
- emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, strings_offset);
- strings_offset += 4;
-
- /* reset ESP(4) */
- emitm_lea_m_r(interp, pc, emit_EAX, emit_EBP, 0, 1, st_offset);
- emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 4);
- break;
- case 's': /* short: movswl intreg_o(base), %eax */
- /* FIXME (TT #1325) emitm_call_cfunc(pc, get_nci_I); */
- emitm_movswl_r_r(pc, emit_EAX, emit_EAX);
- emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, args_offset);
- break;
- case 'c': /* char: movsbl intreg_o(base), %eax */
- /* emitm_call_cfunc(pc, get_nci_I); */
- emitm_movsbl_r_r(pc, emit_EAX, emit_EAX);
- emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, args_offset);
- break;
- case 'J': /* interpreter */
- emitm_movl_m_r(interp, pc, emit_EAX, emit_EBP, 0, 1, 8);
- emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, args_offset);
- arg_count--;
- break;
- case 'p': /* push pmc->data */
- /* FIXME (TT #1325) emitm_call_cfunc(pc, get_nci_p); */
- emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, args_offset);
- break;
- case 'O': /* push PMC * object in P2 */
- case 'P': /* push PMC * */
- case '@':
- /* FIXME (TT #1325) emitm_call_cfunc(pc, get_nci_P); */
- emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, args_offset);
- break;
- case 'v':
- break;
- case 'b': /* buffer (void*) pass Buffer_bufstart(SReg) */
- /* FIXME (TT #1325) emitm_call_cfunc(pc, get_nci_S); */
- emitm_movl_m_r(interp, pc, emit_EAX, emit_EAX, 0, 1,
+ case '0': /* null ptr or such - doesn't consume a reg */
+ jit_emit_bxor_rr_i(interp, pc, emit_EAX, emit_EAX);
+ emitm_movl_m_r(interp, pc, emit_EAX, emit_EBP, 0, 1, args_offset);
+ break;
+ case 'f':
+ /* FIXME (TT #1325) emitm_call_cfunc(pc, get_nci_N); */
+ emitm_fstps(interp, pc, emit_EBP, 0, 1, args_offset);
+ break;
+ case 'N':
+ case 'd':
+ /* FIXME (TT #1325) emitm_call_cfunc(pc, get_nci_N); */
+ emitm_fstpl(interp, pc, emit_EBP, 0, 1, args_offset);
+ args_offset += 4;
+ break;
+ case 'I': /* INTVAL */
+ case 'l': /* long */
+ case 'i': /* int */
+ /* FIXME (TT #1325) emitm_call_cfunc(pc, get_nci_I); */
+ emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, args_offset);
+ break;
+ case 't': /* string, pass a cstring */
+ /* FIXME (TT #1325) emitm_call_cfunc(pc, get_nci_S); */
+ emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 4);
+ emitm_call_cfunc(pc, string_to_cstring_nullable);
+
+ emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, args_offset);
+ /* save off temporary allocation address */
+ emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, strings_offset);
+ strings_offset += 4;
+
+ /* reset ESP(4) */
+ emitm_lea_m_r(interp, pc, emit_EAX, emit_EBP, 0, 1, st_offset);
+ emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 4);
+ break;
+ case 's': /* short: movswl intreg_o(base), %eax */
+ /* FIXME (TT #1325) emitm_call_cfunc(pc, get_nci_I); */
+ emitm_movswl_r_r(pc, emit_EAX, emit_EAX);
+ emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, args_offset);
+ break;
+ case 'c': /* char: movsbl intreg_o(base), %eax */
+ /* emitm_call_cfunc(pc, get_nci_I); */
+ emitm_movsbl_r_r(pc, emit_EAX, emit_EAX);
+ emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, args_offset);
+ break;
+ case 'J': /* interpreter */
+ emitm_movl_m_r(interp, pc, emit_EAX, emit_EBP, 0, 1, 8);
+ emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, args_offset);
+ arg_count--;
+ break;
+ case 'p': /* push pmc->data */
+ /* FIXME (TT #1325) emitm_call_cfunc(pc, get_nci_p); */
+ emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, args_offset);
+ break;
+ case 'O': /* push PMC * object in P2 */
+ case 'P': /* push PMC * */
+ case '@':
+ /* FIXME (TT #1325) emitm_call_cfunc(pc, get_nci_P); */
+ emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, args_offset);
+ break;
+ case 'v':
+ break;
+ case 'b': /* buffer (void*) pass Buffer_bufstart(SReg) */
+ /* FIXME (TT #1325) emitm_call_cfunc(pc, get_nci_S); */
+ emitm_movl_m_r(interp, pc, emit_EAX, emit_EAX, 0, 1,
(size_t) &Buffer_bufstart((STRING *) NULL));
- emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, args_offset);
- break;
- case 'B': /* buffer (void**) pass &Buffer_bufstart(SReg) */
- /* FIXME (TT #1325) emitm_call_cfunc(pc, get_nci_S); */
- emitm_lea_m_r(interp, pc, emit_EAX, emit_EAX, 0, 1,
+ emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, args_offset);
+ break;
+ case 'B': /* buffer (void**) pass &Buffer_bufstart(SReg) */
+ /* FIXME (TT #1325) emitm_call_cfunc(pc, get_nci_S); */
+ emitm_lea_m_r(interp, pc, emit_EAX, emit_EAX, 0, 1,
(size_t) &Buffer_bufstart((STRING *) NULL));
- emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, args_offset);
- break;
- case 'S':
- /* FIXME (TT #1325) emitm_call_cfunc(pc, get_nci_S); */
- emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, args_offset);
- break;
+ emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, args_offset);
+ break;
+ case 'S':
+ /* FIXME (TT #1325) emitm_call_cfunc(pc, get_nci_S); */
+ emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, args_offset);
+ break;
/* I have no idea how to handle these */
- case '2':
- case '3':
- case '4':
- case 'V':
- mem_free_executable(execmem, JIT_ALLOC_SIZE);
- Parrot_str_free_cstring(signature_str);
- return NULL;
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_JIT_ERROR,
+ case '2':
+ case '3':
+ case '4':
+ case 'V':
+ mem_free_executable(execmem, JIT_ALLOC_SIZE);
+ Parrot_str_free_cstring(signature_str);
+ return NULL;
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_JIT_ERROR,
"Unknown arg Signature %c\n", *sig);
- /*
- * oops unknown signature:
- * cleanup and try nci.c
- */
- mem_free_executable(execmem, JIT_ALLOC_SIZE);
- Parrot_str_free_cstring(signature_str);
- return NULL;
+ /*
+ * oops unknown signature:
+ * cleanup and try nci.c
+ */
+ mem_free_executable(execmem, JIT_ALLOC_SIZE);
+ Parrot_str_free_cstring(signature_str);
+ return NULL;
}
args_offset +=4;
arg_count++;
@@ -502,106 +502,106 @@
/* first in signature is the return value */
sig = signature_str; /* the result */
switch (*sig) {
- /* I have no idea how to handle these */
- case '2':
- case '3':
- case '4':
- /* get integer from pointer - untested */
- emitm_movl_m_r(interp, pc, emit_EAX, emit_EAX, 0, 1, 0);
- if (*sig == 2) /* short */
- emitm_movswl_r_r(pc, emit_EAX, emit_EAX);
- /* XXX FIXME (TT #1325) emitm_call_cfunc(pc, set_nci_I);*/
- break;
- case 'f':
- case 'd':
- jit_emit_fstore_mb_n(interp, pc, emit_EBP, temp_calls_offset + 8);
- /* XXX FIXME (TT #1325) emitm_call_cfunc(pc, set_nci_N); */
- /* pop num from st(0) and mov to reg */
- break;
- case 's':
- /* movswl %ax, %eax */
+ /* I have no idea how to handle these */
+ case '2':
+ case '3':
+ case '4':
+ /* get integer from pointer - untested */
+ emitm_movl_m_r(interp, pc, emit_EAX, emit_EAX, 0, 1, 0);
+ if (*sig == 2) /* short */
emitm_movswl_r_r(pc, emit_EAX, emit_EAX);
- emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 8);
- /* XXX FIXME (TT #1325) emitm_call_cfunc(pc, set_nci_I); */
- break;
- case 'c':
- /* movsbl %al, %eax */
- emitm_movsbl_r_r(pc, emit_EAX, emit_EAX);
- emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 8);
- /* XXX FIXME (TT #1325) emitm_call_cfunc(pc, set_nci_I); */
- break;
- case 'I': /* INTVAL */
- case 'l':
- case 'i':
- emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 8);
- /* XXX FIXME (TT #1325) emitm_call_cfunc(pc, set_nci_I); */
- break;
- case 'v': /* void - do nothing */
- break;
- case 'P':
- emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 8);
- /* XXX FIXME (TT #1325) emitm_call_cfunc(pc, set_nci_P); */
- break;
- case 'p': /* make a new unmanaged struct */
- /* save return value on stack */
-
- /* save pointer p */
- emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 12);
-
- /* make new pmc */
- emitm_movl_i_m(pc, enum_class_UnManagedStruct, emit_EBP, 0, 1, temp_calls_offset + 4);
- emitm_call_cfunc(pc, pmc_new);
-
- /* restore pointer p to EDX */
- emitm_movl_m_r(interp, pc, emit_EDX, emit_EBP, 0, 1, temp_calls_offset + 12);
-
- /* copy UnManagedStruct to stack for set_nci_P call */
- emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 8);
-
- /* eax = PMC, get return value into edx */
- /* mov data(%eax), %eax
- mov %edx, ptr(%eax) */
- emitm_movl_m_r(interp, pc, emit_EAX, emit_EAX, 0, 1, offsetof(struct PMC, data));
- emitm_movl_r_m(interp, pc, emit_EDX, emit_EAX, 0, 1,
+ /* XXX FIXME (TT #1325) emitm_call_cfunc(pc, set_nci_I);*/
+ break;
+ case 'f':
+ case 'd':
+ jit_emit_fstore_mb_n(interp, pc, emit_EBP, temp_calls_offset + 8);
+ /* XXX FIXME (TT #1325) emitm_call_cfunc(pc, set_nci_N); */
+ /* pop num from st(0) and mov to reg */
+ break;
+ case 's':
+ /* movswl %ax, %eax */
+ emitm_movswl_r_r(pc, emit_EAX, emit_EAX);
+ emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 8);
+ /* XXX FIXME (TT #1325) emitm_call_cfunc(pc, set_nci_I); */
+ break;
+ case 'c':
+ /* movsbl %al, %eax */
+ emitm_movsbl_r_r(pc, emit_EAX, emit_EAX);
+ emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 8);
+ /* XXX FIXME (TT #1325) emitm_call_cfunc(pc, set_nci_I); */
+ break;
+ case 'I': /* INTVAL */
+ case 'l':
+ case 'i':
+ emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 8);
+ /* XXX FIXME (TT #1325) emitm_call_cfunc(pc, set_nci_I); */
+ break;
+ case 'v': /* void - do nothing */
+ break;
+ case 'P':
+ emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 8);
+ /* XXX FIXME (TT #1325) emitm_call_cfunc(pc, set_nci_P); */
+ break;
+ case 'p': /* make a new unmanaged struct */
+ /* save return value on stack */
+
+ /* save pointer p */
+ emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 12);
+
+ /* make new pmc */
+ emitm_movl_i_m(pc, enum_class_UnManagedStruct, emit_EBP, 0, 1, temp_calls_offset + 4);
+ emitm_call_cfunc(pc, pmc_new);
+
+ /* restore pointer p to EDX */
+ emitm_movl_m_r(interp, pc, emit_EDX, emit_EBP, 0, 1, temp_calls_offset + 12);
+
+ /* copy UnManagedStruct to stack for set_nci_P call */
+ emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 8);
+
+ /* eax = PMC, get return value into edx */
+ /* mov data(%eax), %eax
+ mov %edx, ptr(%eax) */
+ emitm_movl_m_r(interp, pc, emit_EAX, emit_EAX, 0, 1, offsetof(struct PMC, data));
+ emitm_movl_r_m(interp, pc, emit_EDX, emit_EAX, 0, 1,
offsetof(struct Parrot_UnManagedStruct_attributes, ptr));
- /* reset EBP(4) */
- emitm_lea_m_r(interp, pc, emit_EAX, emit_EBP, 0, 1, st_offset);
- emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 4);
-
- /* XXX FIXME (TT #1325) emitm_call_cfunc(pc, set_nci_P); */
- break;
- case 'S':
- emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 8);
- /* XXX FIXME (TT #1325) emitm_call_cfunc(pc, set_nci_S); */
- break;
- case 't': /* string */
- /* EAX is char* */
- emitm_movl_i_m(pc, 0, emit_EBP, 0, 1, temp_calls_offset + 8); /* len */
-
- /* overwrites address of st in EBP(4) */
- emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 4);
-
- emitm_call_cfunc(pc, Parrot_str_new);
-
- emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 8);
-
- /* reset EBP(4) */
- emitm_lea_m_r(interp, pc, emit_EAX, emit_EBP, 0, 1, st_offset);
- emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 4);
-
- /* XXX FIXME (TT #1325) emitm_call_cfunc(pc, set_nci_S); */
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_JIT_ERROR,
+ /* reset EBP(4) */
+ emitm_lea_m_r(interp, pc, emit_EAX, emit_EBP, 0, 1, st_offset);
+ emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 4);
+
+ /* XXX FIXME (TT #1325) emitm_call_cfunc(pc, set_nci_P); */
+ break;
+ case 'S':
+ emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 8);
+ /* XXX FIXME (TT #1325) emitm_call_cfunc(pc, set_nci_S); */
+ break;
+ case 't': /* string */
+ /* EAX is char* */
+ emitm_movl_i_m(pc, 0, emit_EBP, 0, 1, temp_calls_offset + 8); /* len */
+
+ /* overwrites address of st in EBP(4) */
+ emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 4);
+
+ emitm_call_cfunc(pc, Parrot_str_new);
+
+ emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 8);
+
+ /* reset EBP(4) */
+ emitm_lea_m_r(interp, pc, emit_EAX, emit_EBP, 0, 1, st_offset);
+ emitm_movl_r_m(interp, pc, emit_EAX, emit_EBP, 0, 1, temp_calls_offset + 4);
+
+ /* XXX FIXME (TT #1325) emitm_call_cfunc(pc, set_nci_S); */
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_JIT_ERROR,
"Unknown return Signature %c\n", *sig);
- /*
- * oops unknown signature:
- * cleanup and try nci.c
- */
- Parrot_str_free_cstring(signature_str);
- mem_free_executable(execmem, JIT_ALLOC_SIZE);
- return NULL;
+ /*
+ * oops unknown signature:
+ * cleanup and try nci.c
+ */
+ Parrot_str_free_cstring(signature_str);
+ mem_free_executable(execmem, JIT_ALLOC_SIZE);
+ return NULL;
}
/* free temporary strings */
Modified: trunk/src/gc/mark_sweep.c
==============================================================================
--- trunk/src/gc/mark_sweep.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/gc/mark_sweep.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -761,7 +761,7 @@
if (!PObj_COW_TEST(b))
mem_pool->guaranteed_reclaimable += Buffer_buflen(b);
- mem_pool->possibly_reclaimable += Buffer_buflen(b);
+ mem_pool->possibly_reclaimable += Buffer_buflen(b);
}
Buffer_buflen(b) = 0;
Modified: trunk/src/hash.c
==============================================================================
--- trunk/src/hash.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/hash.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -148,7 +148,7 @@
if (s->hashval)
return s->hashval;
- return Parrot_str_to_hashval(interp, s);
+ return Parrot_str_to_hashval(interp, s);
}
@@ -567,43 +567,43 @@
HashBucket *b;
switch (hash->key_type) {
- case Hash_key_type_STRING:
- {
- STRING * const s_key = VTABLE_shift_string(interp, io);
- b = parrot_hash_put(interp, hash, s_key, NULL);
- }
- break;
- case Hash_key_type_int:
- {
- const INTVAL i_key = VTABLE_shift_integer(interp, io);
- b = parrot_hash_put(interp, hash, (void*)i_key, NULL);
- }
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, 1,
+ case Hash_key_type_STRING:
+ {
+ STRING * const s_key = VTABLE_shift_string(interp, io);
+ b = parrot_hash_put(interp, hash, s_key, NULL);
+ }
+ break;
+ case Hash_key_type_int:
+ {
+ const INTVAL i_key = VTABLE_shift_integer(interp, io);
+ b = parrot_hash_put(interp, hash, (void*)i_key, NULL);
+ }
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, 1,
"unimplemented key type");
- break;
+ break;
}
switch (hash->entry_type) {
- case enum_hash_pmc:
- {
- /* this looks awful, but it avoids type-punning warnings */
- void **ptr = &b->value;
- info->thaw_ptr = (PMC **)ptr;
- (info->visit_pmc_now)(interp, NULL, info);
- break;
- }
- case enum_hash_int:
- {
- const INTVAL i = VTABLE_shift_integer(interp, io);
- b->value = (void *)i;
- break;
- }
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, 1,
- "unimplemented value type");
+ case enum_hash_pmc:
+ {
+ /* this looks awful, but it avoids type-punning warnings */
+ void **ptr = &b->value;
+ info->thaw_ptr = (PMC **)ptr;
+ (info->visit_pmc_now)(interp, NULL, info);
break;
+ }
+ case enum_hash_int:
+ {
+ const INTVAL i = VTABLE_shift_integer(interp, io);
+ b->value = (void *)i;
+ break;
+ }
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, 1,
+ "unimplemented value type");
+ break;
}
}
}
@@ -636,29 +636,29 @@
HashBucket * const b = hash->bs+i;
switch (hash->key_type) {
- case Hash_key_type_STRING:
- VTABLE_push_string(interp, io, (STRING *)b->key);
- break;
- case Hash_key_type_int:
- VTABLE_push_integer(interp, io, (INTVAL)b->key);
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, 1,
+ case Hash_key_type_STRING:
+ VTABLE_push_string(interp, io, (STRING *)b->key);
+ break;
+ case Hash_key_type_int:
+ VTABLE_push_integer(interp, io, (INTVAL)b->key);
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, 1,
"unimplemented key type");
- break;
+ break;
}
switch (hash->entry_type) {
- case enum_hash_pmc:
- (info->visit_pmc_now)(interp, (PMC *)b->value, info);
- break;
- case enum_hash_int:
- VTABLE_push_integer(interp, io, (INTVAL)b->value);
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, 1,
+ case enum_hash_pmc:
+ (info->visit_pmc_now)(interp, (PMC *)b->value, info);
+ break;
+ case enum_hash_int:
+ VTABLE_push_integer(interp, io, (INTVAL)b->value);
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, 1,
"unimplemented value type");
- break;
+ break;
}
}
}
@@ -684,16 +684,16 @@
visit_info* const info = (visit_info*) pinfo;
switch (info->what) {
- case VISIT_THAW_NORMAL:
- case VISIT_THAW_CONSTANTS:
- hash_thaw(interp, hash, info);
- break;
- case VISIT_FREEZE_NORMAL:
- case VISIT_FREEZE_AT_DESTRUCT:
- hash_freeze(interp, hash, info);
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, 1,
+ case VISIT_THAW_NORMAL:
+ case VISIT_THAW_CONSTANTS:
+ hash_thaw(interp, hash, info);
+ break;
+ case VISIT_FREEZE_NORMAL:
+ case VISIT_FREEZE_AT_DESTRUCT:
+ hash_freeze(interp, hash, info);
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, 1,
"unimplemented visit mode");
}
}
@@ -1410,26 +1410,26 @@
void * const key = b->key;
switch (hash->entry_type) {
- case enum_type_undef:
- case enum_type_ptr:
- case enum_type_INTVAL:
- valtmp = (void *)b->value;
- break;
+ case enum_type_undef:
+ case enum_type_ptr:
+ case enum_type_INTVAL:
+ valtmp = (void *)b->value;
+ break;
- case enum_type_STRING:
- valtmp = (void *)Parrot_str_copy(interp, (STRING *)b->value);
- break;
+ case enum_type_STRING:
+ valtmp = (void *)Parrot_str_copy(interp, (STRING *)b->value);
+ break;
- case enum_type_PMC:
- if (PMC_IS_NULL((PMC *)b->value))
- valtmp = (void *)PMCNULL;
- else
- valtmp = (void *)VTABLE_clone(interp, (PMC*)b->value);
- break;
+ case enum_type_PMC:
+ if (PMC_IS_NULL((PMC *)b->value))
+ valtmp = (void *)PMCNULL;
+ else
+ valtmp = (void *)VTABLE_clone(interp, (PMC*)b->value);
+ break;
- default:
- valtmp = NULL; /* avoid warning */
- Parrot_ex_throw_from_c_args(interp, NULL, -1,
+ default:
+ valtmp = NULL; /* avoid warning */
+ Parrot_ex_throw_from_c_args(interp, NULL, -1,
"hash corruption: type = %d\n", hash->entry_type);
};
@@ -1533,18 +1533,18 @@
ASSERT_ARGS(hash_key_from_int)
void *ret;
switch (hash->key_type) {
- case Hash_key_type_int:
- ret = (void *)key;
- break;
+ case Hash_key_type_int:
+ ret = (void *)key;
+ break;
/* Currently PMCs are stringified */
- case Hash_key_type_PMC:
- ret = (void *)get_integer_pmc(interp, key);
- break;
- case Hash_key_type_STRING:
- ret = (void *)Parrot_str_from_int(interp, key);
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
+ case Hash_key_type_PMC:
+ ret = (void *)get_integer_pmc(interp, key);
+ break;
+ case Hash_key_type_STRING:
+ ret = (void *)Parrot_str_from_int(interp, key);
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
"Hash: unsupported key_type");
}
return ret;
@@ -1568,24 +1568,24 @@
ASSERT_ARGS(hash_key_from_string)
void *ret;
switch (hash->key_type) {
- case Hash_key_type_int:
- {
- /* Pacify compiler about casting INVTAL to void */
- const INTVAL int_key = Parrot_str_to_int(interp, key);
- ret = INTVAL2PTR(void *, int_key);
- break;
- }
+ case Hash_key_type_int:
+ {
+ /* Pacify compiler about casting INVTAL to void */
+ const INTVAL int_key = Parrot_str_to_int(interp, key);
+ ret = INTVAL2PTR(void *, int_key);
+ break;
+ }
+
+ case Hash_key_type_PMC:
+ ret = get_string_pmc(interp, key);
+ break;
+
+ case Hash_key_type_STRING:
+ ret = key;
+ break;
- case Hash_key_type_PMC:
- ret = get_string_pmc(interp, key);
- break;
-
- case Hash_key_type_STRING:
- ret = key;
- break;
-
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
"Hash: unsupported key_type");
}
return ret;
@@ -1609,51 +1609,51 @@
ASSERT_ARGS(hash_key_from_pmc)
void *ret;
switch (hash->key_type) {
- case Hash_key_type_int:
+ case Hash_key_type_int:
{
const INTVAL int_key = VTABLE_get_integer(interp, key);
ret = INTVAL2PTR(void *, int_key);
break;
}
- case Hash_key_type_PMC:
+ case Hash_key_type_PMC:
{
/* Extract real value from Key (and box it if nessary) */
if (key->vtable->base_type == enum_class_Key)
switch (key_type(interp, key)) {
- case KEY_integer_FLAG:
- key = get_integer_pmc(interp, key_integer(interp, key));
- break;
- case KEY_string_FLAG:
- key = get_string_pmc(interp, key_string(interp, key));
- break;
- case KEY_number_FLAG:
- key = get_number_pmc(interp, key_number(interp, key));
- break;
- case KEY_pmc_FLAG:
- key = key_pmc(interp, key);
- break;
- default:
- /* It's impossible if Keys are same (and they are not) */
- /* So throw exception */
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION,
+ case KEY_integer_FLAG:
+ key = get_integer_pmc(interp, key_integer(interp, key));
+ break;
+ case KEY_string_FLAG:
+ key = get_string_pmc(interp, key_string(interp, key));
+ break;
+ case KEY_number_FLAG:
+ key = get_number_pmc(interp, key_number(interp, key));
+ break;
+ case KEY_pmc_FLAG:
+ key = key_pmc(interp, key);
+ break;
+ default:
+ /* It's impossible if Keys are same (and they are not) */
+ /* So throw exception */
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION,
"hash: unexpected type of Key");
- break;
+ break;
}
ret = key;
break;
}
- case Hash_key_type_STRING:
- {
- STRING * const tmp = VTABLE_get_string(interp, key);
- if (!tmp)
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNEXPECTED_NULL,
+ case Hash_key_type_STRING:
+ {
+ STRING * const tmp = VTABLE_get_string(interp, key);
+ if (!tmp)
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNEXPECTED_NULL,
"hash: can't use null as key");
- ret = (void *)tmp;
- }
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
+ ret = (void *)tmp;
+ }
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
"Hash: unsupported key_type");
}
return ret;
@@ -1676,17 +1676,17 @@
ASSERT_ARGS(hash_key_to_int)
INTVAL ret;
switch (hash->key_type) {
- case Hash_key_type_int:
- ret = (INTVAL)key;
- break;
- case Hash_key_type_PMC:
- ret = VTABLE_get_integer(interp, (PMC *)key);
- break;
- case Hash_key_type_STRING:
- ret = Parrot_str_to_int(interp, (STRING *)key);
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
+ case Hash_key_type_int:
+ ret = (INTVAL)key;
+ break;
+ case Hash_key_type_PMC:
+ ret = VTABLE_get_integer(interp, (PMC *)key);
+ break;
+ case Hash_key_type_STRING:
+ ret = Parrot_str_to_int(interp, (STRING *)key);
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
"Hash: unsupported key_type");
}
return ret;
@@ -1710,20 +1710,20 @@
ASSERT_ARGS(hash_key_to_string)
STRING *ret;
switch (hash->key_type) {
- case Hash_key_type_int:
- ret = Parrot_str_from_int(interp, (INTVAL)key);
- break;
-
- case Hash_key_type_PMC:
- ret = VTABLE_get_string(interp, (PMC *)key);
- break;
-
- case Hash_key_type_STRING:
- ret = (STRING *)key;
- break;
+ case Hash_key_type_int:
+ ret = Parrot_str_from_int(interp, (INTVAL)key);
+ break;
+
+ case Hash_key_type_PMC:
+ ret = VTABLE_get_string(interp, (PMC *)key);
+ break;
+
+ case Hash_key_type_STRING:
+ ret = (STRING *)key;
+ break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
"Hash: unsupported key_type");
}
return ret;
@@ -1746,17 +1746,17 @@
ASSERT_ARGS(hash_key_to_pmc)
PMC *ret;
switch (hash->key_type) {
- case Hash_key_type_int:
- ret = get_integer_pmc(interp, (INTVAL)key);
- break;
- case Hash_key_type_PMC:
- ret = (PMC*)key;
- break;
- case Hash_key_type_STRING:
- ret = get_string_pmc(interp, (STRING*)key);
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
+ case Hash_key_type_int:
+ ret = get_integer_pmc(interp, (INTVAL)key);
+ break;
+ case Hash_key_type_PMC:
+ ret = (PMC*)key;
+ break;
+ case Hash_key_type_STRING:
+ ret = get_string_pmc(interp, (STRING*)key);
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
"Hash: unsupported key_type");
}
return ret;
@@ -1783,20 +1783,20 @@
ASSERT_ARGS(hash_value_from_int)
void *ret;
switch (hash->entry_type) {
- case enum_type_INTVAL:
- ret = INTVAL2PTR(void *, value);
- break;
- case enum_type_PMC:
- {
- PMC * const tmp = get_integer_pmc(interp, value);
- ret = (void *)tmp;
- }
- break;
- case enum_type_STRING:
- ret = (void *)Parrot_str_from_int(interp, value);
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
+ case enum_type_INTVAL:
+ ret = INTVAL2PTR(void *, value);
+ break;
+ case enum_type_PMC:
+ {
+ PMC * const tmp = get_integer_pmc(interp, value);
+ ret = (void *)tmp;
+ }
+ break;
+ case enum_type_STRING:
+ ret = (void *)Parrot_str_from_int(interp, value);
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
"Hash: unsupported entry_type");
}
return ret;
@@ -1821,25 +1821,25 @@
ASSERT_ARGS(hash_value_from_string)
void *ret;
switch (hash->entry_type) {
- case enum_type_INTVAL:
- {
- const INTVAL int_val = STRING_IS_NULL(value) ?
- (INTVAL) 0 : Parrot_str_to_int(interp, value);
- ret = INTVAL2PTR(void *, int_val);
- }
- break;
- case enum_type_STRING:
- ret = (void *)value;
- break;
- case enum_type_PMC:
- {
- PMC * const s = STRING_IS_NULL(value) ?
- PMCNULL : get_string_pmc(interp, value);
- ret = (void *)s;
- }
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
+ case enum_type_INTVAL:
+ {
+ const INTVAL int_val = STRING_IS_NULL(value) ?
+ (INTVAL) 0 : Parrot_str_to_int(interp, value);
+ ret = INTVAL2PTR(void *, int_val);
+ }
+ break;
+ case enum_type_STRING:
+ ret = (void *)value;
+ break;
+ case enum_type_PMC:
+ {
+ PMC * const s = STRING_IS_NULL(value) ?
+ PMCNULL : get_string_pmc(interp, value);
+ ret = (void *)s;
+ }
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
"Hash: unsupported entry_type");
}
return ret;
@@ -1864,22 +1864,22 @@
ASSERT_ARGS(hash_value_from_pmc)
void *ret;
switch (hash->entry_type) {
- case enum_type_INTVAL:
- {
- const INTVAL int_val = PMC_IS_NULL(value) ?
- (INTVAL) 0 : VTABLE_get_integer(interp, value);
- ret = INTVAL2PTR(void *, int_val);
- }
- break;
- case enum_type_STRING:
- ret = PMC_IS_NULL(value) ?
- PMCNULL : (void *)VTABLE_get_string(interp, value);
- break;
- case enum_type_PMC:
- ret = (void *)value;
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
+ case enum_type_INTVAL:
+ {
+ const INTVAL int_val = PMC_IS_NULL(value) ?
+ (INTVAL) 0 : VTABLE_get_integer(interp, value);
+ ret = INTVAL2PTR(void *, int_val);
+ }
+ break;
+ case enum_type_STRING:
+ ret = PMC_IS_NULL(value) ?
+ PMCNULL : (void *)VTABLE_get_string(interp, value);
+ break;
+ case enum_type_PMC:
+ ret = (void *)value;
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
"Hash: unsupported entry_type");
}
return ret;
@@ -1903,23 +1903,23 @@
ASSERT_ARGS(hash_value_from_number)
void *ret;
switch (hash->entry_type) {
- case enum_type_INTVAL:
- {
- const INTVAL tmp = value;
- ret = (void*)tmp;
- }
- break;
- case enum_type_STRING:
- ret = (void *)Parrot_str_from_num(interp, value);
- break;
- case enum_type_PMC:
- {
- PMC * const tmp = get_number_pmc(interp, value);
- ret = (void *)tmp;
- }
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
+ case enum_type_INTVAL:
+ {
+ const INTVAL tmp = value;
+ ret = (void*)tmp;
+ }
+ break;
+ case enum_type_STRING:
+ ret = (void *)Parrot_str_from_num(interp, value);
+ break;
+ case enum_type_PMC:
+ {
+ PMC * const tmp = get_number_pmc(interp, value);
+ ret = (void *)tmp;
+ }
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
"Hash: unsupported entry_type");
}
return ret;
@@ -1942,18 +1942,18 @@
ASSERT_ARGS(hash_value_to_int)
INTVAL ret;
switch (hash->entry_type) {
- case enum_type_ptr:
- case enum_type_INTVAL:
- ret = (INTVAL)value;
- break;
- case enum_type_STRING:
- ret = Parrot_str_to_int(interp, (STRING*)value);
- break;
- case enum_type_PMC:
- ret = VTABLE_get_integer(interp, (PMC*)value);
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
+ case enum_type_ptr:
+ case enum_type_INTVAL:
+ ret = (INTVAL)value;
+ break;
+ case enum_type_STRING:
+ ret = Parrot_str_to_int(interp, (STRING*)value);
+ break;
+ case enum_type_PMC:
+ ret = VTABLE_get_integer(interp, (PMC*)value);
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
"Hash: unsupported entry_type");
}
return ret;
@@ -1977,17 +1977,17 @@
ASSERT_ARGS(hash_value_to_string)
STRING *ret;
switch (hash->entry_type) {
- case enum_type_INTVAL:
- ret = Parrot_str_from_int(interp, (INTVAL)value);
- break;
- case enum_type_STRING:
- ret = (STRING *)value;
- break;
- case enum_type_PMC:
- ret = VTABLE_get_string(interp, (PMC *)value);
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
+ case enum_type_INTVAL:
+ ret = Parrot_str_from_int(interp, (INTVAL)value);
+ break;
+ case enum_type_STRING:
+ ret = (STRING *)value;
+ break;
+ case enum_type_PMC:
+ ret = VTABLE_get_string(interp, (PMC *)value);
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
"Hash: unsupported entry_type");
}
return ret;
@@ -2011,17 +2011,17 @@
ASSERT_ARGS(hash_value_to_pmc)
PMC *ret;
switch (hash->entry_type) {
- case enum_type_INTVAL:
- ret = get_integer_pmc(interp, (INTVAL)value);
- break;
- case enum_type_STRING:
- ret = get_string_pmc(interp, (STRING*)value);
- break;
- case enum_type_PMC:
- ret = (PMC *)value;
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
+ case enum_type_INTVAL:
+ ret = get_integer_pmc(interp, (INTVAL)value);
+ break;
+ case enum_type_STRING:
+ ret = get_string_pmc(interp, (STRING*)value);
+ break;
+ case enum_type_PMC:
+ ret = (PMC *)value;
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
"Hash: unsupported entry_type");
}
return ret;
@@ -2044,21 +2044,21 @@
ASSERT_ARGS(hash_value_to_number)
FLOATVAL ret;
switch (hash->entry_type) {
- case enum_type_INTVAL:
- {
- /* Pacify compiler about casting */
- const INTVAL tmp = (INTVAL)value;
- ret = tmp;
- }
- break;
- case enum_type_STRING:
- ret = Parrot_str_to_num(interp, (STRING*)value);
- break;
- case enum_type_PMC:
- ret = VTABLE_get_number(interp, (PMC*)value);
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
+ case enum_type_INTVAL:
+ {
+ /* Pacify compiler about casting */
+ const INTVAL tmp = (INTVAL)value;
+ ret = tmp;
+ }
+ break;
+ case enum_type_STRING:
+ ret = Parrot_str_to_num(interp, (STRING*)value);
+ break;
+ case enum_type_PMC:
+ ret = VTABLE_get_number(interp, (PMC*)value);
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
"Hash: unsupported entry_type");
}
return ret;
Modified: trunk/src/interp/inter_cb.c
==============================================================================
--- trunk/src/interp/inter_cb.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/interp/inter_cb.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -314,57 +314,57 @@
if (*p == 'U') /* user_data Z in pdd16 */
++p; /* p is now type of external data */
switch (*p) {
- case 'v':
- pasm_sig[1] = 'v';
- break;
+ case 'v':
+ pasm_sig[1] = 'v';
+ break;
#if 0
- case '2':
- case '3':
- case '4':
+ case '2':
+ case '3':
+ case '4':
#endif
- case 'l':
- i_param = (INTVAL)(long) external_data;
- goto case_I;
- case 'i':
- i_param = (INTVAL)(int)(long) external_data;
- goto case_I;
- case 's':
- i_param = (INTVAL)(short)(long) external_data;
- goto case_I;
- case 'c':
- i_param = (INTVAL)(char)(long)external_data;
+ case 'l':
+ i_param = (INTVAL)(long) external_data;
+ goto case_I;
+ case 'i':
+ i_param = (INTVAL)(int)(long) external_data;
+ goto case_I;
+ case 's':
+ i_param = (INTVAL)(short)(long) external_data;
+ goto case_I;
+ case 'c':
+ i_param = (INTVAL)(char)(long)external_data;
case_I:
- pasm_sig[1] = 'I';
- param = (void*) i_param;
- break;
+ pasm_sig[1] = 'I';
+ param = (void*) i_param;
+ break;
#if 0
- case 'f':
- case 'd':
- /* these types don't fit into a pointer, they will not
- * work
- */
- break;
+ case 'f':
+ case 'd':
+ /* these types don't fit into a pointer, they will not
+ * work
+ */
+ break;
#endif
- case 'p':
- /* created a UnManagedStruct */
- p_param = pmc_new(interp, enum_class_UnManagedStruct);
- VTABLE_set_pointer(interp, p_param, external_data);
- pasm_sig[1] = 'P';
- param = (void*) p_param;
- break;
+ case 'p':
+ /* created a UnManagedStruct */
+ p_param = pmc_new(interp, enum_class_UnManagedStruct);
+ VTABLE_set_pointer(interp, p_param, external_data);
+ pasm_sig[1] = 'P';
+ param = (void*) p_param;
+ break;
#if 0
- case 'P':
- pasm_sig[1] = 'P';
- break;
+ case 'P':
+ pasm_sig[1] = 'P';
+ break;
#endif
- case 't':
- pasm_sig[1] = 'S';
- param = Parrot_str_new(interp, external_data, 0);
- break;
- default:
- ch = *p;
- Parrot_str_free_cstring(sig_cstr);
- Parrot_ex_throw_from_c_args(interp, NULL, 1,
+ case 't':
+ pasm_sig[1] = 'S';
+ param = Parrot_str_new(interp, external_data, 0);
+ break;
+ default:
+ ch = *p;
+ Parrot_str_free_cstring(sig_cstr);
+ Parrot_ex_throw_from_c_args(interp, NULL, 1,
"unhandled signature char '%c' in run_cb", ch);
}
Parrot_str_free_cstring(sig_cstr);
Modified: trunk/src/interp/inter_misc.c
==============================================================================
--- trunk/src/interp/inter_misc.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/interp/inter_misc.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -193,43 +193,43 @@
INTVAL ret;
switch (what) {
- case TOTAL_MEM_ALLOC:
- ret = Parrot_gc_total_memory_allocated(interp);
- break;
- case GC_MARK_RUNS:
- ret = Parrot_gc_count_mark_runs(interp);
- break;
- case GC_LAZY_MARK_RUNS:
- ret = Parrot_gc_count_lazy_mark_runs(interp);
- break;
- case GC_COLLECT_RUNS:
- ret = Parrot_gc_count_collect_runs(interp);
- break;
- case ACTIVE_PMCS:
- ret = Parrot_gc_active_pmcs(interp);
- break;
- case ACTIVE_BUFFERS:
- ret = Parrot_gc_active_sized_buffers(interp);
- break;
- case TOTAL_PMCS:
- ret = Parrot_gc_total_pmcs(interp);
- break;
- case TOTAL_BUFFERS:
- ret = Parrot_gc_total_sized_buffers(interp);
- break;
- case HEADER_ALLOCS_SINCE_COLLECT:
- ret = Parrot_gc_headers_alloc_since_last_collect(interp);
- break;
- case MEM_ALLOCS_SINCE_COLLECT:
- ret = Parrot_gc_mem_alloc_since_last_collect(interp);
- break;
- case TOTAL_COPIED:
- ret = Parrot_gc_total_copied(interp);
- break;
- case IMPATIENT_PMCS:
- ret = Parrot_gc_impatient_pmcs(interp);
- break;
- case CURRENT_RUNCORE:
+ case TOTAL_MEM_ALLOC:
+ ret = Parrot_gc_total_memory_allocated(interp);
+ break;
+ case GC_MARK_RUNS:
+ ret = Parrot_gc_count_mark_runs(interp);
+ break;
+ case GC_LAZY_MARK_RUNS:
+ ret = Parrot_gc_count_lazy_mark_runs(interp);
+ break;
+ case GC_COLLECT_RUNS:
+ ret = Parrot_gc_count_collect_runs(interp);
+ break;
+ case ACTIVE_PMCS:
+ ret = Parrot_gc_active_pmcs(interp);
+ break;
+ case ACTIVE_BUFFERS:
+ ret = Parrot_gc_active_sized_buffers(interp);
+ break;
+ case TOTAL_PMCS:
+ ret = Parrot_gc_total_pmcs(interp);
+ break;
+ case TOTAL_BUFFERS:
+ ret = Parrot_gc_total_sized_buffers(interp);
+ break;
+ case HEADER_ALLOCS_SINCE_COLLECT:
+ ret = Parrot_gc_headers_alloc_since_last_collect(interp);
+ break;
+ case MEM_ALLOCS_SINCE_COLLECT:
+ ret = Parrot_gc_mem_alloc_since_last_collect(interp);
+ break;
+ case TOTAL_COPIED:
+ ret = Parrot_gc_total_copied(interp);
+ break;
+ case IMPATIENT_PMCS:
+ ret = Parrot_gc_impatient_pmcs(interp);
+ break;
+ case CURRENT_RUNCORE:
{
STRING *name = interp->run_core->name;
@@ -252,9 +252,9 @@
else if (Parrot_str_equal(interp, name, CONST_STRING(interp, "profiling")))
return PARROT_PROFILING_CORE;
}
- default: /* or a warning only? */
- ret = -1;
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
+ default: /* or a warning only? */
+ ret = -1;
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
"illegal argument in interpinfo");
}
return ret;
@@ -279,22 +279,22 @@
{
ASSERT_ARGS(interpinfo_p)
switch (what) {
- case CURRENT_SUB:
- return Parrot_pcc_get_sub(interp, CURRENT_CONTEXT(interp));
- case CURRENT_CONT:
- {
+ case CURRENT_SUB:
+ return Parrot_pcc_get_sub(interp, CURRENT_CONTEXT(interp));
+ case CURRENT_CONT:
+ {
PMC * const cont = Parrot_pcc_get_continuation(interp, CURRENT_CONTEXT(interp));
if (!PMC_IS_NULL(cont) && cont->vtable->base_type ==
enum_class_RetContinuation)
return VTABLE_clone(interp, cont);
return cont;
- }
- case CURRENT_OBJECT:
- return Parrot_pcc_get_object(interp, CURRENT_CONTEXT(interp));
- case CURRENT_LEXPAD:
- return Parrot_pcc_get_lex_pad(interp, CURRENT_CONTEXT(interp));
- default: /* or a warning only? */
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
+ }
+ case CURRENT_OBJECT:
+ return Parrot_pcc_get_object(interp, CURRENT_CONTEXT(interp));
+ case CURRENT_LEXPAD:
+ return Parrot_pcc_get_lex_pad(interp, CURRENT_CONTEXT(interp));
+ default: /* or a warning only? */
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
"illegal argument in interpinfo");
}
}
@@ -322,7 +322,7 @@
{
ASSERT_ARGS(interpinfo_s)
switch (what) {
- case EXECUTABLE_FULLNAME:
+ case EXECUTABLE_FULLNAME:
{
PMC *exe_name = VTABLE_get_pmc_keyed_int(interp, interp->iglobals,
IGLOBALS_EXECUTABLE);
@@ -330,7 +330,7 @@
return string_from_literal(interp, "");
return VTABLE_get_string(interp, exe_name);
}
- case EXECUTABLE_BASENAME:
+ case EXECUTABLE_BASENAME:
{
STRING *basename;
PMC *exe_name = VTABLE_get_pmc_keyed_int(interp,
@@ -359,10 +359,10 @@
return basename;
}
}
- case RUNTIME_PREFIX:
- return Parrot_get_runtime_path(interp);
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
+ case RUNTIME_PREFIX:
+ return Parrot_get_runtime_path(interp);
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
"illegal argument in interpinfo");
}
}
@@ -393,18 +393,18 @@
{
ASSERT_ARGS(sysinfo_i)
switch (info_wanted) {
- case PARROT_INTSIZE:
- return sizeof (INTVAL);
- case PARROT_FLOATSIZE:
- return sizeof (FLOATVAL);
- case PARROT_POINTERSIZE:
- return sizeof (void *);
- case PARROT_INTMIN:
- return PARROT_INTVAL_MIN;
- case PARROT_INTMAX:
- return PARROT_INTVAL_MAX;
- default:
- return -1;
+ case PARROT_INTSIZE:
+ return sizeof (INTVAL);
+ case PARROT_FLOATSIZE:
+ return sizeof (FLOATVAL);
+ case PARROT_POINTERSIZE:
+ return sizeof (void *);
+ case PARROT_INTMIN:
+ return PARROT_INTVAL_MIN;
+ case PARROT_INTMAX:
+ return PARROT_INTVAL_MAX;
+ default:
+ return -1;
}
}
@@ -435,33 +435,33 @@
{
ASSERT_ARGS(sysinfo_s)
switch (info_wanted) {
- case PARROT_OS:
- return Parrot_str_new_constant(interp, BUILD_OS_NAME);
- case PARROT_OS_VERSION:
+ case PARROT_OS:
+ return Parrot_str_new_constant(interp, BUILD_OS_NAME);
+ case PARROT_OS_VERSION:
#ifdef PARROT_HAS_HEADER_SYSUTSNAME
- {
- struct utsname info;
- if (uname(&info) == 0) {
- return string_make(interp, info.version, strlen(info.version), "ascii", 0);
- }
+ {
+ struct utsname info;
+ if (uname(&info) == 0) {
+ return string_make(interp, info.version, strlen(info.version), "ascii", 0);
}
+ }
#endif
- break;
- case PARROT_OS_VERSION_NUMBER:
+ break;
+ case PARROT_OS_VERSION_NUMBER:
#ifdef PARROT_HAS_HEADER_SYSUTSNAME
- {
- struct utsname info;
- if (uname(&info) == 0) {
- return string_make(interp, info.release, strlen(info.version), "ascii", 0);
- }
+ {
+ struct utsname info;
+ if (uname(&info) == 0) {
+ return string_make(interp, info.release, strlen(info.version), "ascii", 0);
}
+ }
#endif
- break;
- case CPU_ARCH:
- return string_make(interp, PARROT_CPU_ARCH, sizeof (PARROT_CPU_ARCH) - 1, "ascii", 0);
- case CPU_TYPE:
- default:
- break;
+ break;
+ case CPU_ARCH:
+ return string_make(interp, PARROT_CPU_ARCH, sizeof (PARROT_CPU_ARCH) - 1, "ascii", 0);
+ case CPU_TYPE:
+ default:
+ break;
}
return string_from_literal(interp, "");
}
Modified: trunk/src/io/buffer.c
==============================================================================
--- trunk/src/io/buffer.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/io/buffer.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -83,17 +83,17 @@
/* Choose an appropriate buffer size for caller */
switch (bufsize) {
- case 0:
- Parrot_io_set_buffer_size(interp, filehandle, 0);
- break;
- case PIO_UNBOUND:
- Parrot_io_set_buffer_size(interp, filehandle,
+ case 0:
+ Parrot_io_set_buffer_size(interp, filehandle, 0);
+ break;
+ case PIO_UNBOUND:
+ Parrot_io_set_buffer_size(interp, filehandle,
PIO_GETBLKSIZE(Parrot_io_get_os_handle(interp, filehandle)));
- break;
- default:
- Parrot_io_set_buffer_size(interp, filehandle,
+ break;
+ default:
+ Parrot_io_set_buffer_size(interp, filehandle,
(bufsize >= PIO_GRAIN ? bufsize : PIO_GRAIN));
- break;
+ break;
}
buffer_size = Parrot_io_get_buffer_size(interp, filehandle);
@@ -692,20 +692,20 @@
unsigned char *buffer_end = Parrot_io_get_buffer_end(interp, filehandle);
switch (whence) {
- case SEEK_SET:
+ case SEEK_SET:
newpos = offset;
break;
- case SEEK_CUR:
+ case SEEK_CUR:
newpos = file_pos + offset;
break;
- case SEEK_END:
+ case SEEK_END:
newpos = PIO_SEEK(interp, filehandle, offset,
whence);
if (newpos == -1)
return -1;
break;
- default:
+ default:
/* XXX: somehow report the illegal whence value */
return -1;
}
Modified: trunk/src/io/filehandle.c
==============================================================================
--- trunk/src/io/filehandle.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/io/filehandle.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -53,25 +53,25 @@
for (i = 0; i < mode_len; ++i) {
INTVAL s = Parrot_str_indexed(interp, mode_str, i);
switch (s) {
- case 'r':
- flags |= PIO_F_READ;
- break;
- case 'w':
- flags |= PIO_F_WRITE;
- if (!(flags & PIO_F_APPEND)) /* don't truncate if appending */
- flags |= PIO_F_TRUNC;
- break;
- case 'a':
- flags |= PIO_F_APPEND;
- flags |= PIO_F_WRITE;
- if ((flags & PIO_F_TRUNC)) /* don't truncate if appending */
- flags &= ~PIO_F_TRUNC;
- break;
- case 'p':
- flags |= PIO_F_PIPE;
- break;
- default:
- break;
+ case 'r':
+ flags |= PIO_F_READ;
+ break;
+ case 'w':
+ flags |= PIO_F_WRITE;
+ if (!(flags & PIO_F_APPEND)) /* don't truncate if appending */
+ flags |= PIO_F_TRUNC;
+ break;
+ case 'a':
+ flags |= PIO_F_APPEND;
+ flags |= PIO_F_WRITE;
+ if ((flags & PIO_F_TRUNC)) /* don't truncate if appending */
+ flags &= ~PIO_F_TRUNC;
+ break;
+ case 'p':
+ flags |= PIO_F_PIPE;
+ break;
+ default:
+ break;
}
}
Modified: trunk/src/key.c
==============================================================================
--- trunk/src/key.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/key.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -333,40 +333,40 @@
FLOATVAL num_key;
switch (PObj_get_FLAGS(key) & KEY_type_FLAGS) {
- case KEY_integer_FLAG:
- GETATTR_Key_int_key(interp, key, int_key);
- return int_key;
- case KEY_integer_FLAG | KEY_register_FLAG:
- GETATTR_Key_int_key(interp, key, int_key);
- return REG_INT(interp, int_key);
+ case KEY_integer_FLAG:
+ GETATTR_Key_int_key(interp, key, int_key);
+ return int_key;
+ case KEY_integer_FLAG | KEY_register_FLAG:
+ GETATTR_Key_int_key(interp, key, int_key);
+ return REG_INT(interp, int_key);
- case KEY_number_FLAG:
- GETATTR_Key_num_key(interp, key, num_key);
- return (INTVAL)num_key;
- case KEY_number_FLAG | KEY_register_FLAG:
- GETATTR_Key_int_key(interp, key, int_key);
- return (INTVAL)REG_NUM(interp, int_key);
+ case KEY_number_FLAG:
+ GETATTR_Key_num_key(interp, key, num_key);
+ return (INTVAL)num_key;
+ case KEY_number_FLAG | KEY_register_FLAG:
+ GETATTR_Key_int_key(interp, key, int_key);
+ return (INTVAL)REG_NUM(interp, int_key);
- case KEY_pmc_FLAG | KEY_register_FLAG:
- {
+ case KEY_pmc_FLAG | KEY_register_FLAG:
+ {
PMC *reg;
GETATTR_Key_int_key(interp, key, int_key);
reg = REG_PMC(interp, int_key);
return VTABLE_get_integer(interp, reg);
- }
+ }
- case KEY_string_FLAG:
- GETATTR_Key_str_key(interp, key, str_key);
- return Parrot_str_to_int(interp, str_key);
- case KEY_string_FLAG | KEY_register_FLAG:
- {
+ case KEY_string_FLAG:
+ GETATTR_Key_str_key(interp, key, str_key);
+ return Parrot_str_to_int(interp, str_key);
+ case KEY_string_FLAG | KEY_register_FLAG:
+ {
STRING *s_reg;
GETATTR_Key_int_key(interp, key, int_key);
s_reg = REG_STR(interp, int_key);
return Parrot_str_to_int(interp, s_reg);
- }
+ }
- default:
+ default:
break;
}
@@ -397,22 +397,22 @@
FLOATVAL num_key;
switch (PObj_get_FLAGS(key) & KEY_type_FLAGS) {
- case KEY_number_FLAG:
+ case KEY_number_FLAG:
GETATTR_Key_num_key(interp, key, num_key);
return num_key;
- case KEY_number_FLAG | KEY_register_FLAG:
+ case KEY_number_FLAG | KEY_register_FLAG:
GETATTR_Key_int_key(interp, key, int_key);
return REG_NUM(interp, int_key);
- case KEY_pmc_FLAG:
+ case KEY_pmc_FLAG:
return VTABLE_get_number(interp, key);
- case KEY_pmc_FLAG | KEY_register_FLAG:
+ case KEY_pmc_FLAG | KEY_register_FLAG:
{
- PMC *reg;
- GETATTR_Key_int_key(interp, key, int_key);
- reg = REG_PMC(interp, int_key);
- return VTABLE_get_number(interp, reg);
+ PMC *reg;
+ GETATTR_Key_int_key(interp, key, int_key);
+ reg = REG_PMC(interp, int_key);
+ return VTABLE_get_number(interp, reg);
}
- default:
+ default:
Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION,
"Key not a number!\n");
}
@@ -439,7 +439,7 @@
switch (PObj_get_FLAGS(key) & KEY_type_FLAGS) {
/* remember to COW strings instead of returning them directly */
- case KEY_string_FLAG:
+ case KEY_string_FLAG:
{
STRING *s;
GETATTR_Key_str_key(interp, key, s);
@@ -447,7 +447,7 @@
s = Parrot_str_new_COW(interp, s);
return s;
}
- case KEY_string_FLAG | KEY_register_FLAG:
+ case KEY_string_FLAG | KEY_register_FLAG:
{
INTVAL int_key;
STRING *s;
@@ -457,7 +457,7 @@
s = Parrot_str_new_COW(interp, s);
return s;
}
- case KEY_pmc_FLAG | KEY_register_FLAG:
+ case KEY_pmc_FLAG | KEY_register_FLAG:
{
INTVAL int_key;
PMC *reg;
@@ -465,33 +465,33 @@
reg = REG_PMC(interp, int_key);
return VTABLE_get_string(interp, reg);
}
- case KEY_integer_FLAG:
+ case KEY_integer_FLAG:
{
INTVAL int_key;
GETATTR_Key_int_key(interp, key, int_key);
return Parrot_str_from_int(interp, int_key);
}
- case KEY_integer_FLAG | KEY_register_FLAG:
+ case KEY_integer_FLAG | KEY_register_FLAG:
{
INTVAL int_key;
GETATTR_Key_int_key(interp, key, int_key);
return Parrot_str_from_int(interp, REG_INT(interp, int_key));
}
- case KEY_number_FLAG:
+ case KEY_number_FLAG:
{
FLOATVAL num_key;
GETATTR_Key_num_key(interp, key, num_key);
return Parrot_str_from_num(interp, num_key);
}
- case KEY_number_FLAG | KEY_register_FLAG:
+ case KEY_number_FLAG | KEY_register_FLAG:
{
INTVAL int_key;
GETATTR_Key_int_key(interp, key, int_key);
return Parrot_str_from_num(interp, REG_NUM(interp, int_key));
}
- default:
- case KEY_pmc_FLAG:
- return VTABLE_get_string(interp, key);
+ default:
+ case KEY_pmc_FLAG:
+ return VTABLE_get_string(interp, key);
}
}
@@ -517,10 +517,10 @@
INTVAL int_key;
switch (PObj_get_FLAGS(key) & KEY_type_FLAGS) {
- case KEY_pmc_FLAG | KEY_register_FLAG:
+ case KEY_pmc_FLAG | KEY_register_FLAG:
GETATTR_Key_int_key(interp, key, int_key);
return REG_PMC(interp, int_key);
- default:
+ default:
return key;
}
}
@@ -653,57 +653,57 @@
while (key != NULL) {
switch (PObj_get_FLAGS(key) & KEY_type_FLAGS) {
- case KEY_integer_FLAG:
- GETATTR_Key_int_key(interp, key, int_key);
- value = Parrot_str_append(interp, value,
+ case KEY_integer_FLAG:
+ GETATTR_Key_int_key(interp, key, int_key);
+ value = Parrot_str_append(interp, value,
Parrot_str_from_int(interp, int_key));
- break;
- case KEY_number_FLAG:
- GETATTR_Key_int_key(interp, key, int_key);
- value = Parrot_str_append(interp, value,
+ break;
+ case KEY_number_FLAG:
+ GETATTR_Key_int_key(interp, key, int_key);
+ value = Parrot_str_append(interp, value,
Parrot_str_from_num(interp, (FLOATVAL)int_key));
- break;
- case KEY_string_FLAG:
- GETATTR_Key_str_key(interp, key, str_key);
- value = Parrot_str_append(interp, value, quote);
- value = Parrot_str_append(interp, value, str_key);
- value = Parrot_str_append(interp, value, quote);
- break;
- case KEY_pmc_FLAG:
- value = Parrot_str_append(interp, value,
+ break;
+ case KEY_string_FLAG:
+ GETATTR_Key_str_key(interp, key, str_key);
+ value = Parrot_str_append(interp, value, quote);
+ value = Parrot_str_append(interp, value, str_key);
+ value = Parrot_str_append(interp, value, quote);
+ break;
+ case KEY_pmc_FLAG:
+ value = Parrot_str_append(interp, value,
VTABLE_get_string(interp, key));
- break;
- case KEY_integer_FLAG | KEY_register_FLAG:
- GETATTR_Key_int_key(interp, key, int_key);
- value = Parrot_str_append(interp, value,
+ break;
+ case KEY_integer_FLAG | KEY_register_FLAG:
+ GETATTR_Key_int_key(interp, key, int_key);
+ value = Parrot_str_append(interp, value,
Parrot_str_from_int(interp,
REG_INT(interp, int_key)));
- break;
- case KEY_number_FLAG | KEY_register_FLAG:
- GETATTR_Key_int_key(interp, key, int_key);
- value = Parrot_str_append(interp, value,
+ break;
+ case KEY_number_FLAG | KEY_register_FLAG:
+ GETATTR_Key_int_key(interp, key, int_key);
+ value = Parrot_str_append(interp, value,
Parrot_str_from_num(interp,
REG_NUM(interp, int_key)));
- break;
- case KEY_string_FLAG | KEY_register_FLAG:
- value = Parrot_str_append(interp, value, quote);
- GETATTR_Key_int_key(interp, key, int_key);
- value = Parrot_str_append(interp, value,
+ break;
+ case KEY_string_FLAG | KEY_register_FLAG:
+ value = Parrot_str_append(interp, value, quote);
+ GETATTR_Key_int_key(interp, key, int_key);
+ value = Parrot_str_append(interp, value,
REG_STR(interp, int_key));
- value = Parrot_str_append(interp, value, quote);
- break;
- case KEY_pmc_FLAG | KEY_register_FLAG:
- {
+ value = Parrot_str_append(interp, value, quote);
+ break;
+ case KEY_pmc_FLAG | KEY_register_FLAG:
+ {
PMC *reg;
GETATTR_Key_int_key(interp, key, int_key);
reg = REG_PMC(interp, int_key);
value = Parrot_str_append(interp, value,
VTABLE_get_string(interp, reg));
- }
- break;
- default:
- value = Parrot_str_append(interp, value, CONST_STRING(interp, "Key type unknown"));
- break;
+ }
+ break;
+ default:
+ value = Parrot_str_append(interp, value, CONST_STRING(interp, "Key type unknown"));
+ break;
}
GETATTR_Key_next_key(interp, key, next_key);
Modified: trunk/src/list.c
==============================================================================
--- trunk/src/list.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/list.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -1201,33 +1201,33 @@
}
switch (type) {
- case enum_type_sized:
+ case enum_type_sized:
/* copy data into list */
memcpy(&((char *) Buffer_bufstart(&chunk->data))[idx * list->item_size],
item, list->item_size);
break;
- case enum_type_char:
+ case enum_type_char:
((char *) Buffer_bufstart(&chunk->data))[idx] = (char)PTR2INTVAL(item);
break;
- case enum_type_short:
+ case enum_type_short:
((short *) Buffer_bufstart(&chunk->data))[idx] = (short)PTR2INTVAL(item);
break;
- case enum_type_int:
+ case enum_type_int:
((int *) Buffer_bufstart(&chunk->data))[idx] = (int)PTR2INTVAL(item);
break;
- case enum_type_INTVAL:
+ case enum_type_INTVAL:
((INTVAL *) Buffer_bufstart(&chunk->data))[idx] = PTR2INTVAL(item);
break;
- case enum_type_FLOATVAL:
+ case enum_type_FLOATVAL:
((FLOATVAL *) Buffer_bufstart(&chunk->data))[idx] = *(FLOATVAL *)item;
break;
- case enum_type_PMC:
+ case enum_type_PMC:
((PMC **) Buffer_bufstart(&chunk->data))[idx] = (PMC *)item;
break;
- case enum_type_STRING:
+ case enum_type_STRING:
((STRING **) Buffer_bufstart(&chunk->data))[idx] = (STRING *)item;
break;
- default:
+ default:
Parrot_ex_throw_from_c_args(interp, NULL, 1, "Unknown list entry type\n");
break;
}
@@ -1265,25 +1265,25 @@
}
switch (type) {
- case enum_type_sized:
- return (void *)&((char *)
+ case enum_type_sized:
+ return (void *)&((char *)
Buffer_bufstart(&chunk->data))[idx * list->item_size];
- case enum_type_char:
- return (void *)&((char *) Buffer_bufstart(&chunk->data))[idx];
- case enum_type_short:
- return (void *)&((short *) Buffer_bufstart(&chunk->data))[idx];
- case enum_type_int:
- return (void *)&((int *) Buffer_bufstart(&chunk->data))[idx];
- case enum_type_INTVAL:
- return (void *)&((INTVAL *) Buffer_bufstart(&chunk->data))[idx];
- case enum_type_FLOATVAL:
- return (void *)&((FLOATVAL *) Buffer_bufstart(&chunk->data))[idx];
- case enum_type_PMC:
- return (void *)&((PMC **) Buffer_bufstart(&chunk->data))[idx];
- case enum_type_STRING:
- return (void *)&((STRING **) Buffer_bufstart(&chunk->data))[idx];
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, 1, "Unknown list entry type\n");
+ case enum_type_char:
+ return (void *)&((char *) Buffer_bufstart(&chunk->data))[idx];
+ case enum_type_short:
+ return (void *)&((short *) Buffer_bufstart(&chunk->data))[idx];
+ case enum_type_int:
+ return (void *)&((int *) Buffer_bufstart(&chunk->data))[idx];
+ case enum_type_INTVAL:
+ return (void *)&((INTVAL *) Buffer_bufstart(&chunk->data))[idx];
+ case enum_type_FLOATVAL:
+ return (void *)&((FLOATVAL *) Buffer_bufstart(&chunk->data))[idx];
+ case enum_type_PMC:
+ return (void *)&((PMC **) Buffer_bufstart(&chunk->data))[idx];
+ case enum_type_STRING:
+ return (void *)&((STRING **) Buffer_bufstart(&chunk->data))[idx];
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, 1, "Unknown list entry type\n");
}
}
@@ -1344,31 +1344,31 @@
list->item_type = type;
switch (type) {
- case enum_type_sized: /* gets overridden below */
- case enum_type_char:
- list->item_size = sizeof (char);
- break;
- case enum_type_short:
- list->item_size = sizeof (short);
- break;
- case enum_type_int:
- list->item_size = sizeof (int);
- break;
- case enum_type_INTVAL:
- list->item_size = sizeof (INTVAL);
- break;
- case enum_type_FLOATVAL:
- list->item_size = sizeof (FLOATVAL);
- break;
- case enum_type_PMC:
- list->item_size = sizeof (PMC *);
- break;
- case enum_type_STRING:
- list->item_size = sizeof (STRING *);
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, 1, "Unknown list type\n");
- break;
+ case enum_type_sized: /* gets overridden below */
+ case enum_type_char:
+ list->item_size = sizeof (char);
+ break;
+ case enum_type_short:
+ list->item_size = sizeof (short);
+ break;
+ case enum_type_int:
+ list->item_size = sizeof (int);
+ break;
+ case enum_type_INTVAL:
+ list->item_size = sizeof (INTVAL);
+ break;
+ case enum_type_FLOATVAL:
+ list->item_size = sizeof (FLOATVAL);
+ break;
+ case enum_type_PMC:
+ list->item_size = sizeof (PMC *);
+ break;
+ case enum_type_STRING:
+ list->item_size = sizeof (STRING *);
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, 1, "Unknown list type\n");
+ break;
}
return list;
@@ -1443,28 +1443,28 @@
const INTVAL key = VTABLE_get_integer_keyed_int(interp, init, i);
const INTVAL val = i + 1;
switch (key) {
- case 0:
- size = VTABLE_get_integer_keyed_int(interp, init, val);
- break;
- case 1:
- multi_key = VTABLE_get_pmc_keyed_int(interp, init, val);
- break;
- case 2:
- {
+ case 0:
+ size = VTABLE_get_integer_keyed_int(interp, init, val);
+ break;
+ case 1:
+ multi_key = VTABLE_get_pmc_keyed_int(interp, init, val);
+ break;
+ case 2:
+ {
const INTVAL result =
VTABLE_get_integer_keyed_int(interp, init, val);
type = (PARROT_DATA_TYPE)result;
- }
- break;
- case 3:
- item_size = VTABLE_get_integer_keyed_int(interp, init, val);
- break;
- case 4:
- items_per_chunk = VTABLE_get_integer_keyed_int(
+ }
+ break;
+ case 3:
+ item_size = VTABLE_get_integer_keyed_int(interp, init, val);
+ break;
+ case 4:
+ items_per_chunk = VTABLE_get_integer_keyed_int(
interp, init, val);
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, 1,
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, 1,
"Invalid initializer for list\n");
}
}
@@ -1561,7 +1561,7 @@
if (!(new_chunk->flags & sparse)) {
switch (l->item_type) {
- case enum_type_PMC:
+ case enum_type_PMC:
for (i = 0; i < chunk->items; i++) {
PMC * const op = ((PMC **) Buffer_bufstart(&chunk->data))[i];
@@ -1570,7 +1570,7 @@
VTABLE_clone(interp, op);
}
break;
- case enum_type_STRING:
+ case enum_type_STRING:
for (i = 0; i < chunk->items; i++) {
STRING *s = ((STRING **) Buffer_bufstart(&chunk->data))[i];
if (s)
@@ -1578,7 +1578,7 @@
Parrot_str_copy(interp, s);
}
break;
- default:
+ default:
mem_sys_memcopy(Buffer_bufstart(&new_chunk->data),
Buffer_bufstart(&chunk->data), Buffer_buflen(&chunk->data));
break;
Modified: trunk/src/multidispatch.c
==============================================================================
--- trunk/src/multidispatch.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/multidispatch.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -534,26 +534,26 @@
/* Regular arguments just set the value */
switch (type) {
- case 'I':
- VTABLE_set_integer_keyed_int(interp, type_tuple,
+ case 'I':
+ VTABLE_set_integer_keyed_int(interp, type_tuple,
i, enum_type_INTVAL);
- break;
- case 'N':
- VTABLE_set_integer_keyed_int(interp, type_tuple,
+ break;
+ case 'N':
+ VTABLE_set_integer_keyed_int(interp, type_tuple,
i, enum_type_FLOATVAL);
- break;
- case 'S':
- {
- INTVAL type_lookahead = Parrot_str_indexed(interp, string_sig, (i + 1));
- if (type_lookahead == 'n') {
- args_ended = 1;
- break;
- }
- VTABLE_set_integer_keyed_int(interp, type_tuple,
- i, enum_type_STRING);
+ break;
+ case 'S':
+ {
+ INTVAL type_lookahead = Parrot_str_indexed(interp, string_sig, (i + 1));
+ if (type_lookahead == 'n') {
+ args_ended = 1;
break;
}
- case 'P':
+ VTABLE_set_integer_keyed_int(interp, type_tuple,
+ i, enum_type_STRING);
+ break;
+ }
+ case 'P':
{
INTVAL type_lookahead = Parrot_str_indexed(interp, string_sig, (i + 1));
if (type_lookahead == 'i') {
@@ -579,11 +579,11 @@
break;
}
- case '-':
- args_ended = 1;
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL,
+ case '-':
+ args_ended = 1;
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL,
EXCEPTION_INVALID_OPERATION,
"Multiple Dispatch: invalid argument type %c!", type);
}
@@ -768,17 +768,17 @@
/* promote primitives to their PMC equivalents, as PCC will autobox
* the distance penalty makes primitive variants look cheaper */
switch (type_call) {
- case enum_type_INTVAL:
- if (type_sig == enum_class_Integer) { dist++; continue; }
- break;
- case enum_type_FLOATVAL:
- if (type_sig == enum_class_Float) { dist++; continue; }
- break;
- case enum_type_STRING:
- if (type_sig == enum_class_String) { dist++; continue; }
- break;
- default:
- break;
+ case enum_type_INTVAL:
+ if (type_sig == enum_class_Integer) { dist++; continue; }
+ break;
+ case enum_type_FLOATVAL:
+ if (type_sig == enum_class_Float) { dist++; continue; }
+ break;
+ case enum_type_STRING:
+ if (type_sig == enum_class_String) { dist++; continue; }
+ break;
+ default:
+ break;
}
/*
Modified: trunk/src/nci_test.c
==============================================================================
--- trunk/src/nci_test.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/nci_test.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -270,7 +270,7 @@
PARROT_DYNEXT_EXPORT int
nci_i(void)
{
- return nci_dlvar_int;
+ return nci_dlvar_int;
}
/*
@@ -568,135 +568,135 @@
nci_pi(int test)
{
switch (test) {
- case 0:
- {
- static struct {
- int i[2];
- char c;
- } t = {
- {42, 100},
- 'B'
- };
- return &t;
- }
- case 1:
- {
- static struct {
- float f[2];
- double d;
- } t = {
- {42.0, 100.0},
- 47.11
- };
- return &t;
- }
- case 2:
- {
- static struct {
- char c;
+ case 0:
+ {
+ static struct {
+ int i[2];
+ char c;
+ } t = {
+ {42, 100},
+ 'B'
+ };
+ return &t;
+ }
+ case 1:
+ {
+ static struct {
+ float f[2];
+ double d;
+ } t = {
+ {42.0, 100.0},
+ 47.11
+ };
+ return &t;
+ }
+ case 2:
+ {
+ static struct {
+ char c;
+ int i;
+ } t = {
+ 10,
+ 20
+ };
+ return &t;
+ }
+ case 3:
+ {
+ static struct {
+ const char *c;
+ int i;
+ } t = {
+ "hello",
+ 20
+ };
+ return &t;
+ }
+ case 4:
+ {
+ static struct _x {
+ int i;
+ int j;
+ double d;
+ } xx = { 100, 77, 200.0 };
+ static struct {
+ char c;
+ struct _x *x;
+ } t = {
+ 10,
+ &xx
+ };
+ return &t;
+ }
+ case 5:
+ {
+ static struct {
+ int (*f)(const char *);
+ } t = {
+ call_back
+ };
+ return &t;
+ }
+ case 6:
+ {
+ static struct xt {
+ int x;
+ struct yt {
int i;
- } t = {
- 10,
- 20
- };
- return &t;
- }
- case 3:
- {
- static struct {
- const char *c;
- int i;
- } t = {
- "hello",
- 20
- };
- return &t;
- }
- case 4:
- {
- static struct _x {
- int i;
- int j;
- double d;
- } xx = { 100, 77, 200.0 };
- static struct {
- char c;
- struct _x *x;
- } t = {
- 10,
- &xx
- };
- return &t;
- }
- case 5:
- {
- static struct {
- int (*f)(const char *);
- } t = {
- call_back
- };
- return &t;
- }
- case 6:
- {
- static struct xt {
- int x;
- struct yt {
- int i;
- int j;
- } _y;
- int z;
- } _x = {
- 32,
- { 127, 12345 },
- 33
- };
- return &_x;
- }
- case 7:
- {
- static struct xt {
- char x;
- struct yt {
- char i;
- int j;
- } _y;
- char z;
- } _x = {
- 32,
- { 127, 12345 },
- 33
- };
- return &_x;
- }
- case 8:
- {
- static struct _z {
+ int j;
+ } _y;
+ int z;
+ } _x = {
+ 32,
+ { 127, 12345 },
+ 33
+ };
+ return &_x;
+ }
+ case 7:
+ {
+ static struct xt {
+ char x;
+ struct yt {
+ char i;
+ int j;
+ } _y;
+ char z;
+ } _x = {
+ 32,
+ { 127, 12345 },
+ 33
+ };
+ return &_x;
+ }
+ case 8:
+ {
+ static struct _z {
+ int i;
+ int j;
+ } zz = { 100, 77 };
+ static struct xt {
+ int x;
+ struct yt {
int i;
int j;
- } zz = { 100, 77 };
- static struct xt {
- int x;
- struct yt {
- int i;
- int j;
- struct _z *z;
- } _y;
- } _x = {
- 32,
- { 127, 12345, &zz },
- };
- return &_x;
- }
- case 9:
- {
- static int i = 55555;
- return &i;
- }
- case 10:
- return NULL;
- default:
- fprintf(stderr, "unknown test number\n");
+ struct _z *z;
+ } _y;
+ } _x = {
+ 32,
+ { 127, 12345, &zz },
+ };
+ return &_x;
+ }
+ case 9:
+ {
+ static int i = 55555;
+ return &i;
+ }
+ case 10:
+ return NULL;
+ default:
+ fprintf(stderr, "unknown test number\n");
}
return NULL;
@@ -750,13 +750,13 @@
PARROT_DYNEXT_EXPORT void
nci_vP(void *pmc)
{
-/* Disable this test until someone figures a way to check for
- * PMCNULL without using libparrot.
+ /* Disable this test until someone figures a way to check for
+ * PMCNULL without using libparrot.
if (!PMC_IS_NULL(pmc))
puts("ok");
else
-*/
- puts("got null");
+ */
+ puts("got null");
}
@@ -1032,9 +1032,9 @@
PARROT_DYNEXT_EXPORT void *
nci_pii(int fac1, int fac2)
{
- nci_dlvar_int = fac1 * fac2;
+ nci_dlvar_int = fac1 * fac2;
- return &nci_dlvar_int;
+ return &nci_dlvar_int;
}
/*
@@ -1154,9 +1154,9 @@
PARROT_DYNEXT_EXPORT void
nci_vfff(float l1, float l2, float l3)
{
- validate_float(l1, 3456.54);
- validate_float(l2, 10.1999);
- validate_float(l3, 14245.567);
+ validate_float(l1, 3456.54);
+ validate_float(l2, 10.1999);
+ validate_float(l3, 14245.567);
}
@@ -1174,7 +1174,7 @@
PARROT_DYNEXT_EXPORT void
nci_vV(const char **ptr)
{
- *ptr = "Hello bright new world\n";
+ *ptr = "Hello bright new world\n";
}
/*
@@ -1191,9 +1191,9 @@
PARROT_DYNEXT_EXPORT void
nci_vVVV(const char **ptr1, const char **ptr2, const char **ptr3)
{
- *ptr1 = "Hello bright new world!\n";
- *ptr2 = "It is a beautiful day!\n";
- *ptr3 = "Go suck a lemon.\n";
+ *ptr1 = "Hello bright new world!\n";
+ *ptr2 = "It is a beautiful day!\n";
+ *ptr3 = "Go suck a lemon.\n";
}
#ifdef TEST
Modified: trunk/src/oo.c
==============================================================================
--- trunk/src/oo.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/oo.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -110,12 +110,12 @@
void
Parrot_oo_extract_methods_from_namespace(PARROT_INTERP, ARGIN(PMC *self), ARGIN(PMC *ns))
{
- ASSERT_ARGS(Parrot_oo_extract_methods_from_namespace)
- PMC *methods, *vtable_overrides;
+ ASSERT_ARGS(Parrot_oo_extract_methods_from_namespace)
+ PMC *methods, *vtable_overrides;
/* Pull in methods from the namespace, if any. */
- if (PMC_IS_NULL(ns))
- return;
+ if (PMC_IS_NULL(ns))
+ return;
/* Import any methods. */
Parrot_pcc_invoke_method_from_c_args(interp, ns, CONST_STRING(interp, "get_associated_methods"), "->P", &methods);
@@ -169,7 +169,7 @@
PMC *
Parrot_oo_get_namespace(SHIM_INTERP, ARGIN(const PMC *classobj))
{
- ASSERT_ARGS(Parrot_oo_get_namespace)
+ ASSERT_ARGS(Parrot_oo_get_namespace)
Parrot_Class_attributes * const _class = PARROT_CLASS(classobj);
PMC * const _namespace = _class->_namespace;
@@ -204,13 +204,13 @@
else {
/* Fast select of behavior based on type of the lookup key */
switch (key->vtable->base_type) {
- case enum_class_NameSpace:
- classobj = VTABLE_get_class(interp, key);
- break;
- case enum_class_String:
- case enum_class_Key:
- case enum_class_ResizableStringArray:
- {
+ case enum_class_NameSpace:
+ classobj = VTABLE_get_class(interp, key);
+ break;
+ case enum_class_String:
+ case enum_class_Key:
+ case enum_class_ResizableStringArray:
+ {
PMC * const hll_ns = VTABLE_get_pmc_keyed_int(interp,
interp->HLL_namespace,
Parrot_pcc_get_HLL(interp, CURRENT_CONTEXT(interp)));
@@ -219,9 +219,9 @@
if (!PMC_IS_NULL(ns))
classobj = VTABLE_get_class(interp, ns);
- }
- default:
- break;
+ }
+ default:
+ break;
}
}
@@ -624,24 +624,24 @@
return 0;
switch (VTABLE_type(interp, value)) {
- case enum_class_NameSpace:
- return 0;
- break;
- case enum_class_Integer:
- {
- const INTVAL type = VTABLE_get_integer(interp, value);
- if (type < enum_type_undef) {
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION,
+ case enum_class_NameSpace:
+ return 0;
+ break;
+ case enum_class_Integer:
+ {
+ const INTVAL type = VTABLE_get_integer(interp, value);
+ if (type < enum_type_undef) {
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_OPERATION,
"native type with name '%s' already exists - "
"can't register Class", data_types[type].name);
- }
- return type;
}
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INTERP_ERROR,
+ return type;
+ }
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INTERP_ERROR,
"Unrecognized class name PMC type");
- break;
+ break;
}
}
Modified: trunk/src/packdump.c
==============================================================================
--- trunk/src/packdump.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/packdump.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -163,11 +163,11 @@
switch (self->type) {
- case PFC_NUMBER:
+ case PFC_NUMBER:
Parrot_io_printf(interp, " [ 'PFC_NUMBER', %g ],\n", self->u.number);
break;
- case PFC_STRING:
+ case PFC_STRING:
Parrot_io_printf(interp, " [ 'PFC_STRING', {\n");
pobj_flag_dump(interp, (long)PObj_get_FLAGS(self->u.string));
Parrot_io_printf(interp, " CHARSET => %ld,\n",
@@ -181,7 +181,7 @@
Parrot_io_printf(interp, " } ],\n");
break;
- case PFC_KEY:
+ case PFC_KEY:
for (i = 0, key = self->u.key; key; i++) {
GETATTR_Key_next_key(interp, key, key);
}
@@ -196,14 +196,14 @@
type &= KEY_type_FLAGS;
pobj_flag_dump(interp, (long)PObj_get_FLAGS(key));
switch (type) {
- case KEY_integer_FLAG:
- Parrot_io_printf(interp, " TYPE => INTEGER\n");
- Parrot_io_printf(interp, " DATA => %ld\n",
+ case KEY_integer_FLAG:
+ Parrot_io_printf(interp, " TYPE => INTEGER\n");
+ Parrot_io_printf(interp, " DATA => %ld\n",
VTABLE_get_integer(interp, key));
- Parrot_io_printf(interp, " },\n");
- break;
- case KEY_number_FLAG:
- {
+ Parrot_io_printf(interp, " },\n");
+ break;
+ case KEY_number_FLAG:
+ {
const PackFile_Constant *detail;
size_t ct_index;
@@ -213,10 +213,10 @@
detail = ct->constants[ct_index];
Parrot_io_printf(interp, " DATA => %ld\n", detail->u.number);
Parrot_io_printf(interp, " },\n");
- }
- break;
- case KEY_string_FLAG:
- {
+ }
+ break;
+ case KEY_string_FLAG:
+ {
const PackFile_Constant *detail;
size_t ct_index;
@@ -227,42 +227,42 @@
Parrot_io_printf(interp, " DATA => '%Ss'\n",
detail->u.string);
Parrot_io_printf(interp, " },\n");
- }
- break;
- case KEY_integer_FLAG | KEY_register_FLAG:
- Parrot_io_printf(interp, " TYPE => I REGISTER\n");
- Parrot_io_printf(interp, " DATA => %ld\n",
+ }
+ break;
+ case KEY_integer_FLAG | KEY_register_FLAG:
+ Parrot_io_printf(interp, " TYPE => I REGISTER\n");
+ Parrot_io_printf(interp, " DATA => %ld\n",
VTABLE_get_integer(interp, key));
- Parrot_io_printf(interp, " },\n");
- break;
- case KEY_number_FLAG | KEY_register_FLAG:
- Parrot_io_printf(interp, " TYPE => N REGISTER\n");
- Parrot_io_printf(interp, " DATA => %ld\n",
+ Parrot_io_printf(interp, " },\n");
+ break;
+ case KEY_number_FLAG | KEY_register_FLAG:
+ Parrot_io_printf(interp, " TYPE => N REGISTER\n");
+ Parrot_io_printf(interp, " DATA => %ld\n",
VTABLE_get_integer(interp, key));
- Parrot_io_printf(interp, " },\n");
- break;
- case KEY_string_FLAG | KEY_register_FLAG:
- Parrot_io_printf(interp, " TYPE => S REGISTER\n");
- Parrot_io_printf(interp, " DATA => %ld\n",
+ Parrot_io_printf(interp, " },\n");
+ break;
+ case KEY_string_FLAG | KEY_register_FLAG:
+ Parrot_io_printf(interp, " TYPE => S REGISTER\n");
+ Parrot_io_printf(interp, " DATA => %ld\n",
VTABLE_get_integer(interp, key));
- Parrot_io_printf(interp, " },\n");
- break;
- case KEY_pmc_FLAG | KEY_register_FLAG:
- Parrot_io_printf(interp, " TYPE => P REGISTER\n");
- Parrot_io_printf(interp, " DATA => %ld\n",
+ Parrot_io_printf(interp, " },\n");
+ break;
+ case KEY_pmc_FLAG | KEY_register_FLAG:
+ Parrot_io_printf(interp, " TYPE => P REGISTER\n");
+ Parrot_io_printf(interp, " DATA => %ld\n",
VTABLE_get_integer(interp, key));
- Parrot_io_printf(interp, " },\n");
- break;
- default:
- Parrot_io_eprintf(NULL, "PackFile_Constant_pack: "
+ Parrot_io_printf(interp, " },\n");
+ break;
+ default:
+ Parrot_io_eprintf(NULL, "PackFile_Constant_pack: "
"unsupported constant type\n");
- Parrot_exit(interp, 1);
+ Parrot_exit(interp, 1);
}
GETATTR_Key_next_key(interp, key, key);
}
Parrot_io_printf(interp, " ],\n");
break;
- case PFC_PMC:
+ case PFC_PMC:
Parrot_io_printf(interp, " [ 'PFC_PMC', {\n");
{
PMC * const pmc = self->u.key;
@@ -272,16 +272,16 @@
pobj_flag_dump(interp, (long)PObj_get_FLAGS(pmc));
switch (pmc->vtable->base_type) {
- case enum_class_FixedBooleanArray:
- case enum_class_FixedFloatArray:
- case enum_class_FixedPMCArray:
- case enum_class_FixedStringArray:
- case enum_class_ResizableBooleanArray:
- case enum_class_ResizableIntegerArray:
- case enum_class_ResizableFloatArray:
- case enum_class_ResizablePMCArray:
- case enum_class_ResizableStringArray:
- {
+ case enum_class_FixedBooleanArray:
+ case enum_class_FixedFloatArray:
+ case enum_class_FixedPMCArray:
+ case enum_class_FixedStringArray:
+ case enum_class_ResizableBooleanArray:
+ case enum_class_ResizableIntegerArray:
+ case enum_class_ResizableFloatArray:
+ case enum_class_ResizablePMCArray:
+ case enum_class_ResizableStringArray:
+ {
const int n = VTABLE_get_integer(interp, pmc);
STRING* const out_buffer = VTABLE_get_repr(interp, pmc);
Parrot_io_printf(interp,
@@ -291,34 +291,34 @@
pmc->vtable->whoami,
n,
out_buffer);
- }
- break;
- case enum_class_Sub:
- case enum_class_Coroutine:
- PMC_get_sub(interp, pmc, sub);
- if (sub->namespace_name) {
- switch (sub->namespace_name->vtable->base_type) {
- case enum_class_String:
- namespace_description = Parrot_str_new(interp, "'", 1);
- namespace_description = Parrot_str_append(interp,
+ }
+ break;
+ case enum_class_Sub:
+ case enum_class_Coroutine:
+ PMC_get_sub(interp, pmc, sub);
+ if (sub->namespace_name) {
+ switch (sub->namespace_name->vtable->base_type) {
+ case enum_class_String:
+ namespace_description = Parrot_str_new(interp, "'", 1);
+ namespace_description = Parrot_str_append(interp,
namespace_description,
VTABLE_get_string(interp, sub->namespace_name));
- namespace_description = Parrot_str_append(interp,
+ namespace_description = Parrot_str_append(interp,
namespace_description,
Parrot_str_new(interp, "'", 1));
- break;
- case enum_class_Key:
- namespace_description =
+ break;
+ case enum_class_Key:
+ namespace_description =
key_set_to_string(interp, sub->namespace_name);
- break;
- default:
- namespace_description = sub->namespace_name->vtable->whoami;
- }
+ break;
+ default:
+ namespace_description = sub->namespace_name->vtable->whoami;
}
- else {
- namespace_description = null;
- }
- Parrot_io_printf(interp,
+ }
+ else {
+ namespace_description = null;
+ }
+ Parrot_io_printf(interp,
"\tclass => %Ss,\n"
"\tstart_offs => %d,\n"
"\tend_offs => %d,\n"
@@ -337,23 +337,23 @@
sub->ns_entry_name,
namespace_description,
sub->HLL_id);
- break;
- case enum_class_FixedIntegerArray:
- Parrot_io_printf(interp,
+ break;
+ case enum_class_FixedIntegerArray:
+ Parrot_io_printf(interp,
"\tclass => %Ss,\n"
"\trepr => '%Ss'\n",
pmc->vtable->whoami,
VTABLE_get_repr(interp, pmc));
- break;
- default:
- Parrot_io_printf(interp, "\tno dump info for PMC %ld %Ss\n",
+ break;
+ default:
+ Parrot_io_printf(interp, "\tno dump info for PMC %ld %Ss\n",
pmc->vtable->base_type, pmc->vtable->whoami);
- Parrot_io_printf(interp, "\tclass => %Ss,\n", pmc->vtable->whoami);
+ Parrot_io_printf(interp, "\tclass => %Ss,\n", pmc->vtable->whoami);
}
}
Parrot_io_printf(interp, " } ],\n");
break;
- default:
+ default:
Parrot_io_printf(interp, " [ 'PFC_\?\?\?', type '0x%x' ],\n",
self->type);
break;
@@ -380,18 +380,18 @@
for (i = 0; i < ft->fixup_count; i++) {
Parrot_io_printf(interp, "\t#%d\n", (int) i);
switch (ft->fixups[i]->type) {
- case enum_fixup_label:
- case enum_fixup_sub:
- Parrot_io_printf(interp,
+ case enum_fixup_label:
+ case enum_fixup_sub:
+ Parrot_io_printf(interp,
"\ttype => %d offs => %8d name => '%s',\n",
(int)ft->fixups[i]->type,
(int)ft->fixups[i]->offset,
ft->fixups[i]->name);
- break;
- default:
- Parrot_io_printf(interp, "\ttype => %d ???,\n",
+ break;
+ default:
+ Parrot_io_printf(interp, "\ttype => %d ???,\n",
(int) ft->fixups[i]->type);
- break;
+ break;
}
}
}
Modified: trunk/src/packfile.c
==============================================================================
--- trunk/src/packfile.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/packfile.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -564,30 +564,30 @@
PackFile * const pf = seg->pf;
switch (seg->type) {
- case PF_BYTEC_SEG:
- if (!pf->cur_cs)
- pf->cur_cs = (PackFile_ByteCode *)seg;
- break;
- case PF_FIXUP_SEG:
- if (!pf->cur_cs->fixups) {
- pf->cur_cs->fixups = (PackFile_FixupTable *)seg;
- pf->cur_cs->fixups->code = pf->cur_cs;
- }
- break;
- case PF_CONST_SEG:
- if (!pf->cur_cs->const_table) {
- pf->cur_cs->const_table = (PackFile_ConstTable *)seg;
- pf->cur_cs->const_table->code = pf->cur_cs;
- }
- break;
- case PF_UNKNOWN_SEG:
- break;
- case PF_DEBUG_SEG:
- pf->cur_cs->debugs = (PackFile_Debug *)seg;
- pf->cur_cs->debugs->code = pf->cur_cs;
- break;
- default:
- break;
+ case PF_BYTEC_SEG:
+ if (!pf->cur_cs)
+ pf->cur_cs = (PackFile_ByteCode *)seg;
+ break;
+ case PF_FIXUP_SEG:
+ if (!pf->cur_cs->fixups) {
+ pf->cur_cs->fixups = (PackFile_FixupTable *)seg;
+ pf->cur_cs->fixups->code = pf->cur_cs;
+ }
+ break;
+ case PF_CONST_SEG:
+ if (!pf->cur_cs->const_table) {
+ pf->cur_cs->const_table = (PackFile_ConstTable *)seg;
+ pf->cur_cs->const_table->code = pf->cur_cs;
+ }
+ break;
+ case PF_UNKNOWN_SEG:
+ break;
+ case PF_DEBUG_SEG:
+ pf->cur_cs->debugs = (PackFile_Debug *)seg;
+ pf->cur_cs->debugs->code = pf->cur_cs;
+ break;
+ default:
+ break;
}
}
@@ -625,25 +625,25 @@
return 0;
switch (action) {
- case PBC_PBC:
- case PBC_MAIN:
- /* denote MAIN entry in first loaded PASM */
- if (interp->resume_flag & RESUME_INITIAL)
- todo = 1;
-
- /* :init functions need to be called at MAIN time, so return 1 */
- /* symreg.h:P_INIT */
- if (Sub_comp_INIT_TEST(sub))
- todo = 1;
-
- break;
- case PBC_LOADED:
- /* symreg.h:P_LOAD */
- if (pragmas & SUB_FLAG_PF_LOAD)
- todo = 1;
- break;
- default:
- break;
+ case PBC_PBC:
+ case PBC_MAIN:
+ /* denote MAIN entry in first loaded PASM */
+ if (interp->resume_flag & RESUME_INITIAL)
+ todo = 1;
+
+ /* :init functions need to be called at MAIN time, so return 1 */
+ /* symreg.h:P_INIT */
+ if (Sub_comp_INIT_TEST(sub))
+ todo = 1;
+
+ break;
+ case PBC_LOADED:
+ /* symreg.h:P_LOAD */
+ if (pragmas & SUB_FLAG_PF_LOAD)
+ todo = 1;
+ break;
+ default:
+ break;
}
if (pragmas & (SUB_FLAG_PF_IMMEDIATE | SUB_FLAG_PF_POSTCOMP))
@@ -709,74 +709,74 @@
PMC_get_sub(interp, sub_pmc, sub);
switch (action) {
- case PBC_IMMEDIATE:
- /* run IMMEDIATE sub */
- if (PObj_get_FLAGS(sub_pmc) & SUB_FLAG_PF_IMMEDIATE) {
- void *lo_var_ptr = interp->lo_var_ptr;
- PMC *result;
-
- PObj_get_FLAGS(sub_pmc) &= ~SUB_FLAG_PF_IMMEDIATE;
- result = run_sub(interp, sub_pmc);
-
- /* reset initial flag so MAIN detection works
- * and reset lo_var_ptr to prev */
- interp->resume_flag = RESUME_INITIAL;
- interp->lo_var_ptr = lo_var_ptr;
- return result;
- }
- break;
- case PBC_POSTCOMP:
- /* run POSTCOMP sub */
- if (PObj_get_FLAGS(sub_pmc) & SUB_FLAG_PF_POSTCOMP) {
- PObj_get_FLAGS(sub_pmc) &= ~SUB_FLAG_PF_POSTCOMP;
- run_sub(interp, sub_pmc);
+ case PBC_IMMEDIATE:
+ /* run IMMEDIATE sub */
+ if (PObj_get_FLAGS(sub_pmc) & SUB_FLAG_PF_IMMEDIATE) {
+ void *lo_var_ptr = interp->lo_var_ptr;
+ PMC *result;
+
+ PObj_get_FLAGS(sub_pmc) &= ~SUB_FLAG_PF_IMMEDIATE;
+ result = run_sub(interp, sub_pmc);
+
+ /* reset initial flag so MAIN detection works
+ * and reset lo_var_ptr to prev */
+ interp->resume_flag = RESUME_INITIAL;
+ interp->lo_var_ptr = lo_var_ptr;
+ return result;
+ }
+ break;
+ case PBC_POSTCOMP:
+ /* run POSTCOMP sub */
+ if (PObj_get_FLAGS(sub_pmc) & SUB_FLAG_PF_POSTCOMP) {
+ PObj_get_FLAGS(sub_pmc) &= ~SUB_FLAG_PF_POSTCOMP;
+ run_sub(interp, sub_pmc);
- /* reset initial flag so MAIN detection works */
- interp->resume_flag = RESUME_INITIAL;
- return NULL;
- }
- break;
+ /* reset initial flag so MAIN detection works */
+ interp->resume_flag = RESUME_INITIAL;
+ return NULL;
+ }
+ break;
- case PBC_LOADED:
- if (PObj_get_FLAGS(sub_pmc) & SUB_FLAG_PF_LOAD) {
- PObj_get_FLAGS(sub_pmc) &= ~SUB_FLAG_PF_LOAD;
-
- /* if loaded no need for init */
- Sub_comp_INIT_CLEAR(sub);
- run_sub(interp, sub_pmc);
- }
- break;
- default:
- if (PObj_get_FLAGS(sub_pmc) & SUB_FLAG_PF_MAIN) {
- if ((interp->resume_flag & RESUME_INITIAL)
- && interp->resume_offset == 0) {
- void *ptr = VTABLE_get_pointer(interp, sub_pmc);
- const ptrdiff_t code = (ptrdiff_t) sub->seg->base.data;
+ case PBC_LOADED:
+ if (PObj_get_FLAGS(sub_pmc) & SUB_FLAG_PF_LOAD) {
+ PObj_get_FLAGS(sub_pmc) &= ~SUB_FLAG_PF_LOAD;
+
+ /* if loaded no need for init */
+ Sub_comp_INIT_CLEAR(sub);
+ run_sub(interp, sub_pmc);
+ }
+ break;
+ default:
+ if (PObj_get_FLAGS(sub_pmc) & SUB_FLAG_PF_MAIN) {
+ if ((interp->resume_flag & RESUME_INITIAL)
+ && interp->resume_offset == 0) {
+ void *ptr = VTABLE_get_pointer(interp, sub_pmc);
+ const ptrdiff_t code = (ptrdiff_t) sub->seg->base.data;
- interp->resume_offset = ((ptrdiff_t)ptr - code)
- / sizeof (opcode_t *);
+ interp->resume_offset = ((ptrdiff_t)ptr - code)
+ / sizeof (opcode_t *);
- PObj_get_FLAGS(sub_pmc) &= ~SUB_FLAG_PF_MAIN;
- Parrot_pcc_set_sub(interp, CURRENT_CONTEXT(interp), sub_pmc);
- }
- else {
- Parrot_warn(interp, PARROT_WARNINGS_ALL_FLAG,
+ PObj_get_FLAGS(sub_pmc) &= ~SUB_FLAG_PF_MAIN;
+ Parrot_pcc_set_sub(interp, CURRENT_CONTEXT(interp), sub_pmc);
+ }
+ else {
+ Parrot_warn(interp, PARROT_WARNINGS_ALL_FLAG,
":main sub not allowed\n");
- }
}
+ }
- /* run :init tagged functions */
- if (action == PBC_MAIN && Sub_comp_INIT_TEST(sub)) {
- /* if loaded no need for init */
- Sub_comp_INIT_CLEAR(sub);
+ /* run :init tagged functions */
+ if (action == PBC_MAIN && Sub_comp_INIT_TEST(sub)) {
+ /* if loaded no need for init */
+ Sub_comp_INIT_CLEAR(sub);
- /* if inited no need for load */
- PObj_get_FLAGS(sub_pmc) &= ~SUB_FLAG_PF_LOAD;
+ /* if inited no need for load */
+ PObj_get_FLAGS(sub_pmc) &= ~SUB_FLAG_PF_LOAD;
- run_sub(interp, sub_pmc);
- interp->resume_flag = RESUME_INITIAL;
- }
- break;
+ run_sub(interp, sub_pmc);
+ interp->resume_flag = RESUME_INITIAL;
+ }
+ break;
}
return NULL;
@@ -805,18 +805,18 @@
PMC * pmc;
STRING * string;
switch (constants[i]->type) {
- case PFC_PMC:
- case PFC_KEY:
- pmc = constants[i]->u.key;
- Parrot_gc_mark_PMC_alive(interp, pmc);
- break;
- case PFC_STRING:
- string = constants[i]->u.string;
- Parrot_gc_mark_STRING_alive(interp, string);
- break;
- default:
- /* Do nothing. */
- break;
+ case PFC_PMC:
+ case PFC_KEY:
+ pmc = constants[i]->u.key;
+ Parrot_gc_mark_PMC_alive(interp, pmc);
+ break;
+ case PFC_STRING:
+ string = constants[i]->u.string;
+ Parrot_gc_mark_STRING_alive(interp, string);
+ break;
+ default:
+ /* Do nothing. */
+ break;
}
}
}
@@ -3331,15 +3331,15 @@
/* fixup_entry type */
size++;
switch (ft->fixups[i]->type) {
- case enum_fixup_label:
- case enum_fixup_sub:
- size += PF_size_cstring(ft->fixups[i]->name);
- size ++; /* offset */
- break;
- case enum_fixup_none:
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, 1,
+ case enum_fixup_label:
+ case enum_fixup_sub:
+ size += PF_size_cstring(ft->fixups[i]->name);
+ size ++; /* offset */
+ break;
+ case enum_fixup_none:
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, 1,
"Unknown fixup type\n");
}
}
@@ -3373,15 +3373,15 @@
for (i = 0; i < ft->fixup_count; i++) {
*cursor++ = (opcode_t) ft->fixups[i]->type;
switch (ft->fixups[i]->type) {
- case enum_fixup_label:
- case enum_fixup_sub:
- cursor = PF_store_cstring(cursor, ft->fixups[i]->name);
- *cursor++ = ft->fixups[i]->offset;
- break;
- case enum_fixup_none:
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, 1,
+ case enum_fixup_label:
+ case enum_fixup_sub:
+ cursor = PF_store_cstring(cursor, ft->fixups[i]->name);
+ *cursor++ = ft->fixups[i]->offset;
+ break;
+ case enum_fixup_none:
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, 1,
"Unknown fixup type\n");
}
}
@@ -3471,21 +3471,21 @@
entry->type = PF_fetch_opcode(pf, &cursor);
switch (entry->type) {
- case enum_fixup_label:
- case enum_fixup_sub:
- entry->name = PF_fetch_cstring(pf, &cursor);
- entry->offset = PF_fetch_opcode(pf, &cursor);
- TRACE_PRINTF_VAL(("PackFile_FixupTable_unpack(): type %d, "
+ case enum_fixup_label:
+ case enum_fixup_sub:
+ entry->name = PF_fetch_cstring(pf, &cursor);
+ entry->offset = PF_fetch_opcode(pf, &cursor);
+ TRACE_PRINTF_VAL(("PackFile_FixupTable_unpack(): type %d, "
"name %s, offset %ld\n",
entry->type, entry->name, entry->offset));
- break;
- case enum_fixup_none:
- break;
- default:
- Parrot_io_eprintf(interp,
+ break;
+ case enum_fixup_none:
+ break;
+ default:
+ Parrot_io_eprintf(interp,
"PackFile_FixupTable_unpack: Unknown fixup type %d!\n",
entry->type);
- return NULL;
+ return NULL;
}
}
@@ -3858,40 +3858,40 @@
size_t packed_size;
switch (self->type) {
- case PFC_NUMBER:
- packed_size = PF_size_number();
- break;
-
- case PFC_STRING:
- packed_size = PF_size_string(self->u.string);
- break;
-
- case PFC_KEY:
- packed_size = 1;
-
- for (component = self->u.key; component;){
- packed_size += 2;
- GETATTR_Key_next_key(interp, component, component);
- }
- break;
+ case PFC_NUMBER:
+ packed_size = PF_size_number();
+ break;
+
+ case PFC_STRING:
+ packed_size = PF_size_string(self->u.string);
+ break;
+
+ case PFC_KEY:
+ packed_size = 1;
+
+ for (component = self->u.key; component;){
+ packed_size += 2;
+ GETATTR_Key_next_key(interp, component, component);
+ }
+ break;
- case PFC_PMC:
- component = self->u.key; /* the pmc (Sub, ...) */
+ case PFC_PMC:
+ component = self->u.key; /* the pmc (Sub, ...) */
- /*
- * TODO create either
- * a) a frozen_size freeze entry or
- * b) change packout.c so that component size isn't needed
- */
- image = Parrot_freeze(interp, component);
- packed_size = PF_size_string(image);
- break;
+ /*
+ * TODO create either
+ * a) a frozen_size freeze entry or
+ * b) change packout.c so that component size isn't needed
+ */
+ image = Parrot_freeze(interp, component);
+ packed_size = PF_size_string(image);
+ break;
- default:
- Parrot_io_eprintf(NULL,
+ default:
+ Parrot_io_eprintf(NULL,
"Constant_packed_size: Unrecognized type '%c'!\n",
(char)self->type);
- return 0;
+ return 0;
}
/* Tack on space for the initial type field */
@@ -3930,30 +3930,28 @@
type, (char)type));
switch (type) {
- case PFC_NUMBER:
- self->u.number = PF_fetch_number(pf, &cursor);
- self->type = PFC_NUMBER;
- break;
-
- case PFC_STRING:
- self->u.string = PF_fetch_string(interp, pf, &cursor);
- self->type = PFC_STRING;
- break;
-
- case PFC_KEY:
- cursor = PackFile_Constant_unpack_key(interp, constt,
- self, cursor);
- break;
-
- case PFC_PMC:
- cursor = PackFile_Constant_unpack_pmc(interp, constt,
- self, cursor);
- break;
- default:
- Parrot_io_eprintf(NULL,
+ case PFC_NUMBER:
+ self->u.number = PF_fetch_number(pf, &cursor);
+ self->type = PFC_NUMBER;
+ break;
+
+ case PFC_STRING:
+ self->u.string = PF_fetch_string(interp, pf, &cursor);
+ self->type = PFC_STRING;
+ break;
+
+ case PFC_KEY:
+ cursor = PackFile_Constant_unpack_key(interp, constt, self, cursor);
+ break;
+
+ case PFC_PMC:
+ cursor = PackFile_Constant_unpack_pmc(interp, constt, self, cursor);
+ break;
+ default:
+ Parrot_io_eprintf(NULL,
"Constant_unpack: Unrecognized type '%c' during unpack!\n",
(char)type);
- return NULL;
+ return NULL;
}
return cursor;
@@ -4061,29 +4059,29 @@
op = PF_fetch_opcode(pf, &cursor);
switch (type) {
- case PARROT_ARG_IC:
- key_set_integer(interp, tail, op);
- break;
- case PARROT_ARG_NC:
- key_set_number(interp, tail, constt->constants[op]->u.number);
- break;
- case PARROT_ARG_SC:
- key_set_string(interp, tail, constt->constants[op]->u.string);
- break;
- case PARROT_ARG_I:
- key_set_register(interp, tail, op, KEY_integer_FLAG);
- break;
- case PARROT_ARG_N:
- key_set_register(interp, tail, op, KEY_number_FLAG);
- break;
- case PARROT_ARG_S:
- key_set_register(interp, tail, op, KEY_string_FLAG);
- break;
- case PARROT_ARG_P:
- key_set_register(interp, tail, op, KEY_pmc_FLAG);
- break;
- default:
- return NULL;
+ case PARROT_ARG_IC:
+ key_set_integer(interp, tail, op);
+ break;
+ case PARROT_ARG_NC:
+ key_set_number(interp, tail, constt->constants[op]->u.number);
+ break;
+ case PARROT_ARG_SC:
+ key_set_string(interp, tail, constt->constants[op]->u.string);
+ break;
+ case PARROT_ARG_I:
+ key_set_register(interp, tail, op, KEY_integer_FLAG);
+ break;
+ case PARROT_ARG_N:
+ key_set_register(interp, tail, op, KEY_number_FLAG);
+ break;
+ case PARROT_ARG_S:
+ key_set_register(interp, tail, op, KEY_string_FLAG);
+ break;
+ case PARROT_ARG_P:
+ key_set_register(interp, tail, op, KEY_pmc_FLAG);
+ break;
+ default:
+ return NULL;
}
}
@@ -4539,18 +4537,18 @@
PMC *result;
switch (type) {
- case PF_ANNOTATION_KEY_TYPE_INT:
- result = pmc_new(interp, enum_class_Integer);
- VTABLE_set_integer_native(interp, result, value);
- break;
- case PF_ANNOTATION_KEY_TYPE_NUM:
- result = pmc_new(interp, enum_class_Float);
- VTABLE_set_number_native(interp, result,
+ case PF_ANNOTATION_KEY_TYPE_INT:
+ result = pmc_new(interp, enum_class_Integer);
+ VTABLE_set_integer_native(interp, result, value);
+ break;
+ case PF_ANNOTATION_KEY_TYPE_NUM:
+ result = pmc_new(interp, enum_class_Float);
+ VTABLE_set_number_native(interp, result,
PF_CONST(self->code, value)->u.number);
- break;
- default:
- result = pmc_new(interp, enum_class_String);
- VTABLE_set_string_native(interp, result,
+ break;
+ default:
+ result = pmc_new(interp, enum_class_String);
+ VTABLE_set_string_native(interp, result,
PF_CONST(self->code, value)->u.string);
}
Modified: trunk/src/packout.c
==============================================================================
--- trunk/src/packout.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/packout.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -276,21 +276,21 @@
switch (self->type) {
- case PFC_NUMBER:
+ case PFC_NUMBER:
cursor = PF_store_number(cursor, &self->u.number);
break;
- case PFC_STRING:
+ case PFC_STRING:
cursor = PF_store_string(cursor, self->u.string);
break;
- case PFC_PMC:
+ case PFC_PMC:
key = self->u.key; /* the (Sub) PMC */
image = Parrot_freeze(interp, key);
cursor = PF_store_string(cursor, image);
break;
- case PFC_KEY:
+ case PFC_KEY:
for (i = 0, key = self->u.key; key; i++){
GETATTR_Key_next_key(interp, key, key);
}
@@ -302,48 +302,48 @@
const opcode_t type = PObj_get_FLAGS(key);
switch (type & KEY_type_FLAGS) {
- case KEY_integer_FLAG:
- *cursor++ = PARROT_ARG_IC;
- GETATTR_Key_int_key(interp, key, *cursor++);
- break;
- case KEY_number_FLAG:
- *cursor++ = PARROT_ARG_NC;
- /* Argh */
- *cursor++ = PackFile_find_in_const(interp, const_table, key, PFC_NUMBER);
- break;
- case KEY_string_FLAG:
- *cursor++ = PARROT_ARG_SC;
- /* Argh */
- *cursor++ = PackFile_find_in_const(interp, const_table, key, PFC_STRING);
- break;
-
- case KEY_integer_FLAG | KEY_register_FLAG:
- *cursor++ = PARROT_ARG_I;
- GETATTR_Key_int_key(interp, key, *cursor++);
- break;
- case KEY_number_FLAG | KEY_register_FLAG:
- *cursor++ = PARROT_ARG_N;
- GETATTR_Key_int_key(interp, key, *cursor++);
- break;
- case KEY_string_FLAG | KEY_register_FLAG:
- *cursor++ = PARROT_ARG_S;
- GETATTR_Key_int_key(interp, key, *cursor++);
- break;
- case KEY_pmc_FLAG | KEY_register_FLAG:
- *cursor++ = PARROT_ARG_P;
- GETATTR_Key_int_key(interp, key, *cursor++);
- break;
- default:
- Parrot_io_eprintf(NULL, "PackFile_Constant_pack: "
+ case KEY_integer_FLAG:
+ *cursor++ = PARROT_ARG_IC;
+ GETATTR_Key_int_key(interp, key, *cursor++);
+ break;
+ case KEY_number_FLAG:
+ *cursor++ = PARROT_ARG_NC;
+ /* Argh */
+ *cursor++ = PackFile_find_in_const(interp, const_table, key, PFC_NUMBER);
+ break;
+ case KEY_string_FLAG:
+ *cursor++ = PARROT_ARG_SC;
+ /* Argh */
+ *cursor++ = PackFile_find_in_const(interp, const_table, key, PFC_STRING);
+ break;
+
+ case KEY_integer_FLAG | KEY_register_FLAG:
+ *cursor++ = PARROT_ARG_I;
+ GETATTR_Key_int_key(interp, key, *cursor++);
+ break;
+ case KEY_number_FLAG | KEY_register_FLAG:
+ *cursor++ = PARROT_ARG_N;
+ GETATTR_Key_int_key(interp, key, *cursor++);
+ break;
+ case KEY_string_FLAG | KEY_register_FLAG:
+ *cursor++ = PARROT_ARG_S;
+ GETATTR_Key_int_key(interp, key, *cursor++);
+ break;
+ case KEY_pmc_FLAG | KEY_register_FLAG:
+ *cursor++ = PARROT_ARG_P;
+ GETATTR_Key_int_key(interp, key, *cursor++);
+ break;
+ default:
+ Parrot_io_eprintf(NULL, "PackFile_Constant_pack: "
"unsupported constant type\n");
- Parrot_exit(interp, 1);
+ Parrot_exit(interp, 1);
}
GETATTR_Key_next_key(interp, key, key);
}
break;
- default:
+ default:
Parrot_io_eprintf(NULL, "PackFile_Constant_pack: unsupported constant\n");
Parrot_exit(interp, 1);
break;
Modified: trunk/src/pbc_disassemble.c
==============================================================================
--- trunk/src/pbc_disassemble.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/pbc_disassemble.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -103,24 +103,24 @@
while ((status = longopt_get(interp,
argc, argv, options, &opt)) > 0) {
switch (opt.opt_id) {
- case 'h':
- option += enum_DIS_HEADER;
- break;
- case 'b':
- option += enum_DIS_BARE;
- break;
- case 'o':
- outfile = opt.opt_arg;
- break;
+ case 'h':
+ option += enum_DIS_HEADER;
+ break;
+ case 'b':
+ option += enum_DIS_BARE;
+ break;
+ case 'o':
+ outfile = opt.opt_arg;
+ break;
#if TRACE_PACKFILE
- case 'D':
- debug += atoi(opt.opt_arg) << 2;
- break;
+ case 'D':
+ debug += atoi(opt.opt_arg) << 2;
+ break;
#endif
- case '?':
- default:
- help();
- break;
+ case '?':
+ default:
+ help();
+ break;
}
}
if (status == -1) {
Modified: trunk/src/pbc_dump.c
==============================================================================
--- trunk/src/pbc_dump.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/pbc_dump.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -249,28 +249,28 @@
while ((status = longopt_get(interp,
argc, argv, opt_options, &opt)) > 0) {
switch (opt.opt_id) {
- case 'h':
- options += PFOPT_HEADERONLY;
- break;
- case 't':
- terse = 1;
- break;
- case 'd':
- disas = 1;
- break;
+ case 'h':
+ options += PFOPT_HEADERONLY;
+ break;
+ case 't':
+ terse = 1;
+ break;
+ case 'd':
+ disas = 1;
+ break;
#if TRACE_PACKFILE
- case 'D':
- options += atoi(opt.opt_arg) << 2;
- break;
+ case 'D':
+ options += atoi(opt.opt_arg) << 2;
+ break;
#endif
- case 'o':
- file = opt.opt_arg;
- convert = 1;
- break;
- case '?':
- default:
- help();
- break;
+ case 'o':
+ file = opt.opt_arg;
+ convert = 1;
+ break;
+ case '?':
+ default:
+ help();
+ break;
}
}
if (status == -1) {
Modified: trunk/src/pbc_merge.c
==============================================================================
--- trunk/src/pbc_merge.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/pbc_merge.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -436,17 +436,17 @@
/* If it's a sub PMC, need to deal with offsets. */
if (copy->type == PFC_PMC) {
switch (copy->u.key->vtable->base_type) {
- case enum_class_Sub:
- case enum_class_Coroutine:
- {
+ case enum_class_Sub:
+ case enum_class_Coroutine:
+ {
Parrot_Sub_attributes *sub;
PMC_get_sub(interp, copy->u.key, sub);
sub->start_offs += inputs[i]->code_start;
sub->end_offs += inputs[i]->code_start;
- }
- break;
- default:
- break;
+ }
+ break;
+ default:
+ break;
}
}
@@ -537,15 +537,15 @@
/* Set new offset and bytecode pointer. */
switch (copy->type) {
- case enum_fixup_label:
- copy->offset = cur_entry->offset + inputs[i]->code_start;
- break;
- case enum_fixup_sub:
- copy->offset = cur_entry->offset + inputs[i]->const_start;
- break;
- default:
- Parrot_io_eprintf(interp, "PBC Merge: Unknown fixup type");
- Parrot_exit(interp, 1);
+ case enum_fixup_label:
+ copy->offset = cur_entry->offset + inputs[i]->code_start;
+ break;
+ case enum_fixup_sub:
+ copy->offset = cur_entry->offset + inputs[i]->const_start;
+ break;
+ default:
+ Parrot_io_eprintf(interp, "PBC Merge: Unknown fixup type");
+ Parrot_exit(interp, 1);
}
/* Slot it into the list. */
@@ -672,14 +672,14 @@
for (cur_arg = 1; cur_arg < op->op_count; cur_arg++) {
/* Pick out any indexes into the constant table and correct them. */
switch (op->types[cur_arg - 1]) {
- case PARROT_ARG_NC:
- case PARROT_ARG_PC:
- case PARROT_ARG_SC:
- case PARROT_ARG_KC:
- ops[cur_op] += inputs[cur_input]->const_start;
- break;
- default:
- break;
+ case PARROT_ARG_NC:
+ case PARROT_ARG_PC:
+ case PARROT_ARG_SC:
+ case PARROT_ARG_KC:
+ ops[cur_op] += inputs[cur_input]->const_start;
+ break;
+ default:
+ break;
}
/* Move along the bytecode array. */
@@ -698,14 +698,14 @@
const int sig_items = VTABLE_elements(interp, sig);
for (cur_arg = 0; cur_arg < sig_items; cur_arg++) {
switch (VTABLE_get_integer_keyed_int(interp, sig, cur_arg)) {
- case PARROT_ARG_NC:
- case PARROT_ARG_PC:
- case PARROT_ARG_SC:
- case PARROT_ARG_KC:
- ops[cur_op] += inputs[cur_input]->const_start;
- break;
- default:
- break;
+ case PARROT_ARG_NC:
+ case PARROT_ARG_PC:
+ case PARROT_ARG_SC:
+ case PARROT_ARG_KC:
+ ops[cur_op] += inputs[cur_input]->const_start;
+ break;
+ default:
+ break;
}
cur_op++;
}
@@ -834,17 +834,17 @@
}
while ((status = longopt_get(interp, argc, argv, options, &opt)) > 0) {
switch (opt.opt_id) {
- case 'o':
- if (output_file == NULL)
- output_file = opt.opt_arg;
- else
- help(interp);
- break;
- case '?':
+ case 'o':
+ if (output_file == NULL)
+ output_file = opt.opt_arg;
+ else
help(interp);
- break;
- default:
- break;
+ break;
+ case '?':
+ help(interp);
+ break;
+ default:
+ break;
}
}
if (status == -1 || !output_file) {
Modified: trunk/src/pmc_freeze.c
==============================================================================
--- trunk/src/pmc_freeze.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/pmc_freeze.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -739,14 +739,14 @@
{
ASSERT_ARGS(do_action)
switch (info->what) {
- case VISIT_FREEZE_AT_DESTRUCT:
- case VISIT_FREEZE_NORMAL:
- freeze_pmc(interp, pmc, info, seen, id);
- if (pmc)
- info->visit_action = pmc->vtable->freeze;
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, 1, "Illegal action %ld",
+ case VISIT_FREEZE_AT_DESTRUCT:
+ case VISIT_FREEZE_NORMAL:
+ freeze_pmc(interp, pmc, info, seen, id);
+ if (pmc)
+ info->visit_action = pmc->vtable->freeze;
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, 1, "Illegal action %ld",
(long)info->what);
}
}
@@ -772,14 +772,14 @@
ASSERT_ARGS(thaw_create_pmc)
PMC *pmc;
switch (info->what) {
- case VISIT_THAW_NORMAL:
- pmc = pmc_new_noinit(interp, type);
- break;
- case VISIT_THAW_CONSTANTS:
- pmc = constant_pmc_new_noinit(interp, type);
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, 1,
+ case VISIT_THAW_NORMAL:
+ pmc = pmc_new_noinit(interp, type);
+ break;
+ case VISIT_THAW_CONSTANTS:
+ pmc = constant_pmc_new_noinit(interp, type);
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, 1,
"Illegal visit_next type");
}
Modified: trunk/src/runcore/main.c
==============================================================================
--- trunk/src/runcore/main.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/runcore/main.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -255,8 +255,8 @@
switch (type) {
- case PARROT_ARG_KI:
- case PARROT_ARG_I:
+ case PARROT_ARG_KI:
+ case PARROT_ARG_I:
if (arg < 0 || arg >= regs_i)
Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INTERP_ERROR,
"Illegal register number");
@@ -264,7 +264,7 @@
pc_prederef[i] = (void *)REG_OFFS_INT(arg);
break;
- case PARROT_ARG_N:
+ case PARROT_ARG_N:
if (arg < 0 || arg >= regs_n)
Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INTERP_ERROR,
"Illegal register number");
@@ -272,8 +272,8 @@
pc_prederef[i] = (void *)REG_OFFS_NUM(arg);
break;
- case PARROT_ARG_K:
- case PARROT_ARG_P:
+ case PARROT_ARG_K:
+ case PARROT_ARG_P:
if (arg < 0 || arg >= regs_p)
Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INTERP_ERROR,
"Illegal register number");
@@ -281,7 +281,7 @@
pc_prederef[i] = (void *)REG_OFFS_PMC(arg);
break;
- case PARROT_ARG_S:
+ case PARROT_ARG_S:
if (arg < 0 || arg >= regs_s)
Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INTERP_ERROR,
"Illegal register number");
@@ -289,12 +289,12 @@
pc_prederef[i] = (void *)REG_OFFS_STR(arg);
break;
- case PARROT_ARG_KIC:
- case PARROT_ARG_IC:
+ case PARROT_ARG_KIC:
+ case PARROT_ARG_IC:
pc_prederef[i] = (void *)pc[i];
break;
- case PARROT_ARG_NC:
+ case PARROT_ARG_NC:
if (arg < 0 || arg >= const_table->const_count)
Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INTERP_ERROR,
"Illegal constant number");
@@ -302,7 +302,7 @@
pc_prederef[i] = (void *)&const_table->constants[arg]->u.number;
break;
- case PARROT_ARG_SC:
+ case PARROT_ARG_SC:
if (arg < 0 || arg >= const_table->const_count)
Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INTERP_ERROR,
"Illegal constant number");
@@ -310,15 +310,15 @@
pc_prederef[i] = (void *)const_table->constants[arg]->u.string;
break;
- case PARROT_ARG_PC:
- case PARROT_ARG_KC:
+ case PARROT_ARG_PC:
+ case PARROT_ARG_KC:
if (arg < 0 || arg >= const_table->const_count)
Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INTERP_ERROR,
"Illegal constant number");
pc_prederef[i] = (void *)const_table->constants[arg]->u.key;
break;
- default:
+ default:
Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_ARG_OP_NOT_HANDLED,
"Unhandled argtype 0x%x\n", type);
break;
Modified: trunk/src/runcore/trace.c
==============================================================================
--- trunk/src/runcore/trace.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/runcore/trace.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -197,13 +197,13 @@
while (key) {
switch (PObj_get_FLAGS(key) & KEY_type_FLAGS) {
- case KEY_integer_FLAG:
+ case KEY_integer_FLAG:
len += Parrot_io_eprintf(debugger, "%vi", VTABLE_get_integer(interp, key));
break;
- case KEY_number_FLAG:
+ case KEY_number_FLAG:
len += Parrot_io_eprintf(debugger, "%vg", VTABLE_get_number(interp, key));
break;
- case KEY_string_FLAG:
+ case KEY_string_FLAG:
{
const STRING * const s = key_string(interp, key);
STRING* const escaped = Parrot_str_escape_truncate(
@@ -214,15 +214,15 @@
len += Parrot_io_eprintf(debugger, "\"(null)\"");
}
break;
- case KEY_integer_FLAG|KEY_register_FLAG:
+ case KEY_integer_FLAG|KEY_register_FLAG:
len += Parrot_io_eprintf(debugger, "I%vd=%vd", VTABLE_get_integer(interp, key),
REG_INT(interp, VTABLE_get_integer(interp, key)));
break;
- case KEY_number_FLAG|KEY_register_FLAG:
+ case KEY_number_FLAG|KEY_register_FLAG:
len += Parrot_io_eprintf(debugger, "I%vd=%vd", VTABLE_get_integer(interp, key),
REG_NUM(interp, VTABLE_get_integer(interp, key)));
break;
- case KEY_string_FLAG|KEY_register_FLAG:
+ case KEY_string_FLAG|KEY_register_FLAG:
{
const STRING * const s = REG_STR(interp, VTABLE_get_integer(interp, key));
STRING* const escaped = Parrot_str_escape_truncate(
@@ -235,11 +235,11 @@
VTABLE_get_integer(interp, key));
}
break;
- case KEY_pmc_FLAG|KEY_register_FLAG:
+ case KEY_pmc_FLAG|KEY_register_FLAG:
len += Parrot_io_eprintf(debugger, "P%vd=", VTABLE_get_integer(interp, key));
trace_pmc_dump(debugger, REG_PMC(interp, VTABLE_get_integer(interp, key)));
break;
- default:
+ default:
len += Parrot_io_eprintf(debugger, "??");
key = NULL;
break;
@@ -333,21 +333,21 @@
len += Parrot_io_eprintf(debugger, ", ");
}
switch (type) {
- case PARROT_ARG_IC:
- len += Parrot_io_eprintf(debugger, "%vd", o);
- break;
- case PARROT_ARG_NC:
- len += Parrot_io_eprintf(debugger, "%vg", PCONST(o)->u.number);
- break;
- case PARROT_ARG_PC:
- if (var_args)
- len += Parrot_io_eprintf(debugger, "PC%d (%d)",
+ case PARROT_ARG_IC:
+ len += Parrot_io_eprintf(debugger, "%vd", o);
+ break;
+ case PARROT_ARG_NC:
+ len += Parrot_io_eprintf(debugger, "%vg", PCONST(o)->u.number);
+ break;
+ case PARROT_ARG_PC:
+ if (var_args)
+ len += Parrot_io_eprintf(debugger, "PC%d (%d)",
(int)o, var_args);
- else
- len += Parrot_io_eprintf(debugger, "PC%d", (int)o);
- break;
- case PARROT_ARG_SC:
- {
+ else
+ len += Parrot_io_eprintf(debugger, "PC%d", (int)o);
+ break;
+ case PARROT_ARG_SC:
+ {
STRING* const escaped = Parrot_str_escape_truncate(
interp,
PCONST(o)->u.string, 20);
@@ -355,42 +355,42 @@
len += Parrot_io_eprintf(debugger, "\"%Ss\"", escaped);
else
len += Parrot_io_eprintf(debugger, "\"(null)\"");
- }
- break;
- case PARROT_ARG_KC:
- len += trace_key_dump(interp, PCONST(o)->u.key);
- break;
- case PARROT_ARG_KIC:
- len += Parrot_io_eprintf(debugger, "[%vd]", o);
- break;
- case PARROT_ARG_KI:
- len += Parrot_io_eprintf(debugger, "[I%vd]", o);
- more = 1;
- break;
- case PARROT_ARG_K:
- len += Parrot_io_eprintf(debugger, "[P%vd]", o);
- more = 1;
- break;
- case PARROT_ARG_I:
- len += Parrot_io_eprintf(debugger, "I%vd", o);
- more = 1;
- break;
- case PARROT_ARG_N:
- len += Parrot_io_eprintf(debugger, "N%vd", o);
- more = 1;
- break;
- case PARROT_ARG_P:
- len += Parrot_io_eprintf(debugger, "P%vd", o);
- more = 1;
- break;
- case PARROT_ARG_S:
- len += Parrot_io_eprintf(debugger, "S%vd", o);
- more = 1;
- break;
- default:
- Parrot_ex_throw_from_c_args(interp, NULL, 1,
+ }
+ break;
+ case PARROT_ARG_KC:
+ len += trace_key_dump(interp, PCONST(o)->u.key);
+ break;
+ case PARROT_ARG_KIC:
+ len += Parrot_io_eprintf(debugger, "[%vd]", o);
+ break;
+ case PARROT_ARG_KI:
+ len += Parrot_io_eprintf(debugger, "[I%vd]", o);
+ more = 1;
+ break;
+ case PARROT_ARG_K:
+ len += Parrot_io_eprintf(debugger, "[P%vd]", o);
+ more = 1;
+ break;
+ case PARROT_ARG_I:
+ len += Parrot_io_eprintf(debugger, "I%vd", o);
+ more = 1;
+ break;
+ case PARROT_ARG_N:
+ len += Parrot_io_eprintf(debugger, "N%vd", o);
+ more = 1;
+ break;
+ case PARROT_ARG_P:
+ len += Parrot_io_eprintf(debugger, "P%vd", o);
+ more = 1;
+ break;
+ case PARROT_ARG_S:
+ len += Parrot_io_eprintf(debugger, "S%vd", o);
+ more = 1;
+ break;
+ default:
+ Parrot_ex_throw_from_c_args(interp, NULL, 1,
"unhandled type in trace");
- break;
+ break;
}
}
if (!more)
@@ -417,39 +417,39 @@
Parrot_io_eprintf(debugger, " ");
}
switch (type) {
- case PARROT_ARG_I:
- Parrot_io_eprintf(debugger, "I%vd=%vd", o, REG_INT(interp, o));
- break;
- case PARROT_ARG_N:
- Parrot_io_eprintf(debugger, "N%vd=%vf", o, REG_NUM(interp, o));
- break;
- case PARROT_ARG_PC:
- Parrot_io_eprintf(debugger, "PC%vd=", o);
- trace_pmc_dump(interp, PCONST(o)->u.key);
- break;
- case PARROT_ARG_P:
- Parrot_io_eprintf(debugger, "P%vd=", o);
- trace_pmc_dump(interp, REG_PMC(interp, o));
- break;
- case PARROT_ARG_S:
- if (REG_STR(interp, o)) {
- STRING* const escaped = Parrot_str_escape_truncate(
+ case PARROT_ARG_I:
+ Parrot_io_eprintf(debugger, "I%vd=%vd", o, REG_INT(interp, o));
+ break;
+ case PARROT_ARG_N:
+ Parrot_io_eprintf(debugger, "N%vd=%vf", o, REG_NUM(interp, o));
+ break;
+ case PARROT_ARG_PC:
+ Parrot_io_eprintf(debugger, "PC%vd=", o);
+ trace_pmc_dump(interp, PCONST(o)->u.key);
+ break;
+ case PARROT_ARG_P:
+ Parrot_io_eprintf(debugger, "P%vd=", o);
+ trace_pmc_dump(interp, REG_PMC(interp, o));
+ break;
+ case PARROT_ARG_S:
+ if (REG_STR(interp, o)) {
+ STRING* const escaped = Parrot_str_escape_truncate(
interp, REG_STR(interp, o), 20);
- Parrot_io_eprintf(debugger, "S%vd=\"%Ss\"", o,
+ Parrot_io_eprintf(debugger, "S%vd=\"%Ss\"", o,
escaped);
- }
- else
- Parrot_io_eprintf(debugger, "S%vd=\"(null)\"", o);
- break;
- case PARROT_ARG_K:
- Parrot_io_eprintf(debugger, "P%vd=", o);
- trace_key_dump(interp, REG_PMC(interp, *(pc + i)));
- break;
- case PARROT_ARG_KI:
- Parrot_io_eprintf(debugger, "I%vd=[%vd]", o, REG_INT(interp, o));
- break;
- default:
- break;
+ }
+ else
+ Parrot_io_eprintf(debugger, "S%vd=\"(null)\"", o);
+ break;
+ case PARROT_ARG_K:
+ Parrot_io_eprintf(debugger, "P%vd=", o);
+ trace_key_dump(interp, REG_PMC(interp, *(pc + i)));
+ break;
+ case PARROT_ARG_KI:
+ Parrot_io_eprintf(debugger, "I%vd=[%vd]", o, REG_INT(interp, o));
+ break;
+ default:
+ break;
}
}
}
Modified: trunk/src/scheduler.c
==============================================================================
--- trunk/src/scheduler.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/scheduler.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -537,20 +537,20 @@
PMC *handler = VTABLE_get_pmc_keyed_int(interp, handlers, index);
if (!PMC_IS_NULL(handler)) {
switch (htype) {
- case Hexception:
- if (VTABLE_isa(interp, handler, handler_name)) {
- VTABLE_set_pmc_keyed_int(interp, handlers, index, PMCNULL);
- return;
- }
- break;
- case Hevent:
- if (handler->vtable->base_type == enum_class_EventHandler) {
- VTABLE_set_pmc_keyed_int(interp, handlers, index, PMCNULL);
- return;
- }
- break;
- default:
- break;
+ case Hexception:
+ if (VTABLE_isa(interp, handler, handler_name)) {
+ VTABLE_set_pmc_keyed_int(interp, handlers, index, PMCNULL);
+ return;
+ }
+ break;
+ case Hevent:
+ if (handler->vtable->base_type == enum_class_EventHandler) {
+ VTABLE_set_pmc_keyed_int(interp, handlers, index, PMCNULL);
+ return;
+ }
+ break;
+ default:
+ break;
}
}
}
@@ -611,16 +611,16 @@
PMC *handler = VTABLE_get_pmc_keyed_int(interp, handlers, index);
if (!PMC_IS_NULL(handler)) {
switch (htype) {
- case Hexception:
- if (VTABLE_isa(interp, handler, handler_name))
- count++;
- break;
- case Hevent:
- if (handler->vtable->base_type == enum_class_EventHandler)
- count++;
- break;
- default:
- break;
+ case Hexception:
+ if (VTABLE_isa(interp, handler, handler_name))
+ count++;
+ break;
+ case Hevent:
+ if (handler->vtable->base_type == enum_class_EventHandler)
+ count++;
+ break;
+ default:
+ break;
}
}
}
Modified: trunk/src/spf_render.c
==============================================================================
--- trunk/src/spf_render.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/spf_render.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -469,49 +469,49 @@
switch (info.phase) {
/*@fallthrough@ */ case PHASE_FLAGS:
switch (ch) {
- case '-':
+ case '-':
info.flags |= FLAG_MINUS;
continue;
- case '+':
+ case '+':
info.flags |= FLAG_PLUS;
continue;
- case '0':
+ case '0':
info.flags |= FLAG_ZERO;
continue;
- case ' ':
+ case ' ':
info.flags |= FLAG_SPACE;
continue;
- case '#':
+ case '#':
info.flags |= FLAG_SHARP;
continue;
- default:
+ default:
info.phase = PHASE_WIDTH;
}
/*@fallthrough@ */ case PHASE_WIDTH:
switch (ch) {
- case '0':
- case '1':
- case '2':
- case '3':
- case '4':
- case '5':
- case '6':
- case '7':
- case '8':
- case '9':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
info.flags |= FLAG_WIDTH;
info.width *= 10;
info.width += ch - '0';
continue;
- case '*':
+ case '*':
info.flags |= FLAG_WIDTH;
num = obj->getint(interp, SIZE_XVAL, obj);
if (num < 0) {
@@ -523,75 +523,75 @@
}
continue;
- case '.':
+ case '.':
info.phase = PHASE_PREC;
continue;
- default:
+ default:
info.phase = PHASE_PREC;
}
/*@fallthrough@ */ case PHASE_PREC:
switch (ch) {
- case '0':
- case '1':
- case '2':
- case '3':
- case '4':
- case '5':
- case '6':
- case '7':
- case '8':
- case '9':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
+ case '9':
info.flags |= FLAG_PREC;
info.prec *= 10;
info.prec += ch - '0';
continue;
- case '*':
+ case '*':
info.flags |= FLAG_PREC;
info.prec = (UINTVAL)obj->getint(interp,
SIZE_XVAL, obj);
info.phase = PHASE_TYPE;
continue;
- default:
+ default:
info.phase = PHASE_TYPE;
}
/*@fallthrough@ */ case PHASE_TYPE:
switch (ch) {
- case 'h':
+ case 'h':
info.type = SIZE_SHORT;
continue;
- case 'l':
+ case 'l':
info.type = SIZE_LONG;
continue;
- case 'L':
- case 'H':
+ case 'L':
+ case 'H':
info.type = SIZE_HUGE;
continue;
- case 'v':
+ case 'v':
info.type = SIZE_XVAL;
continue;
- case 'O':
+ case 'O':
info.type = SIZE_OPCODE;
continue;
- case 'P':
+ case 'P':
info.type = SIZE_PMC;
continue;
- case 'S':
+ case 'S':
info.type = SIZE_PSTR;
continue;
- default:
+ default:
info.phase = PHASE_TERM;
}
@@ -599,7 +599,7 @@
/*@fallthrough@ */ case PHASE_TERM:
switch (ch) {
/* INTEGERS */
- case 'c':
+ case 'c':
{
STRING * const ts = string_chr(interp,
(UINTVAL)obj->getint(interp, info.type, obj));
@@ -607,7 +607,7 @@
}
break;
- case 'o':
+ case 'o':
{
const UHUGEINTVAL theuint =
obj->getuint(interp, info.type, obj);
@@ -622,7 +622,7 @@
}
break;
- case 'x':
+ case 'x':
{
const UHUGEINTVAL theuint =
obj->getuint(interp, info.type, obj);
@@ -637,7 +637,7 @@
}
break;
- case 'X':
+ case 'X':
{
STRING * const prefix = CONST_STRING(interp, "0X");
const UHUGEINTVAL theuint =
@@ -653,7 +653,7 @@
}
break;
- case 'b':
+ case 'b':
{
STRING * const prefix = CONST_STRING(interp, "0b");
const UHUGEINTVAL theuint =
@@ -668,7 +668,7 @@
}
break;
- case 'B':
+ case 'B':
{
STRING * const prefix = CONST_STRING(interp, "0B");
const HUGEINTVAL theint =
@@ -683,15 +683,15 @@
}
break;
- case 'u':
+ case 'u':
{
const UHUGEINTVAL theuint =
obj->getuint(interp, info.type, obj);
sharedint = theuint;
}
goto do_sprintf;
- case 'd':
- case 'i':
+ case 'd':
+ case 'i':
/* EVIL: Work around bug in glibc that makes %0lld
* sometimes output an empty string. */
@@ -699,7 +699,7 @@
info.flags &= ~FLAG_ZERO;
sharedint = obj->getint(interp, info.type, obj);
- do_sprintf:
+ do_sprintf:
{
STRING *ts;
gen_sprintf_call(tc, &info, ch);
@@ -721,7 +721,7 @@
}
break;
- case 'p':
+ case 'p':
{
STRING * const prefix = CONST_STRING(interp, "0x");
const void * const ptr =
@@ -735,11 +735,11 @@
break;
/* FLOATS - We cheat on these and use snprintf. */
- case 'e':
- case 'E':
- case 'f':
- case 'g':
- case 'G':
+ case 'e':
+ case 'E':
+ case 'f':
+ case 'g':
+ case 'G':
{
STRING *ts;
const HUGEFLOATVAL thefloat =
@@ -822,7 +822,7 @@
break;
/* STRINGS */
- case 'r': /* Python repr */
+ case 'r': /* Python repr */
/* XXX the right fix is to add a getrepr entry *
* to SPRINTF_OBJ, but for now, getstring_pmc *
* is inlined and modified to call get_repr */
@@ -841,7 +841,7 @@
break;
}
- case 's':
+ case 's':
CASE_s:
{
STRING * const string = obj->getstring(interp,
@@ -855,7 +855,7 @@
}
break;
- default:
+ default:
/* fake the old %P and %S commands */
if (info.type == SIZE_PMC
|| info.type == SIZE_PSTR) {
@@ -875,8 +875,8 @@
info.phase = PHASE_DONE;
break;
- case PHASE_DONE:
- default:
+ case PHASE_DONE:
+ default:
/* This is the terminating condition of the surrounding
* loop, so...
*/
Modified: trunk/src/spf_vtable.c
==============================================================================
--- trunk/src/spf_vtable.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/spf_vtable.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -209,30 +209,32 @@
va_list * const arg = (va_list *)(obj->data);
switch (size) {
- case SIZE_REG:
+ case SIZE_REG:
return va_arg(*arg, int);
- case SIZE_SHORT:
+ case SIZE_SHORT:
/* "'short int' is promoted to 'int' when passed through '...'" */
return (short)va_arg(*arg, int);
- case SIZE_LONG:
+ case SIZE_LONG:
return va_arg(*arg, long);
- case SIZE_HUGE:
+ case SIZE_HUGE:
return va_arg(*arg, HUGEINTVAL);
- case SIZE_XVAL:
+ case SIZE_XVAL:
return va_arg(*arg, INTVAL);
- case SIZE_OPCODE:
+ case SIZE_OPCODE:
return va_arg(*arg, opcode_t);
- case SIZE_PMC:{
+ case SIZE_PMC:
+ {
PMC * const pmc = (PMC *)va_arg(*arg, PMC *);
return VTABLE_get_integer(interp, pmc);
}
- default:
+
+ default:
PANIC(interp, "Invalid int type!");
}
}
@@ -260,30 +262,32 @@
va_list * const arg = (va_list *)(obj->data);
switch (size) {
- case SIZE_REG:
+ case SIZE_REG:
return va_arg(*arg, unsigned int);
- case SIZE_SHORT:
+ case SIZE_SHORT:
/* short int promoted HLAGHLAGHLAGH. See note above */
return (unsigned short)va_arg(*arg, unsigned int);
- case SIZE_LONG:
+ case SIZE_LONG:
return va_arg(*arg, unsigned long);
- case SIZE_HUGE:
+ case SIZE_HUGE:
return va_arg(*arg, UHUGEINTVAL);
- case SIZE_XVAL:
+ case SIZE_XVAL:
return va_arg(*arg, UINTVAL);
- case SIZE_OPCODE:
+ case SIZE_OPCODE:
return va_arg(*arg, opcode_t);
- case SIZE_PMC:{
+ case SIZE_PMC:
+ {
PMC * const pmc = va_arg(*arg, PMC *);
return (UINTVAL)VTABLE_get_integer(interp, pmc);
}
- default:
+
+ default:
PANIC(interp, "Invalid uint type!");
}
}
@@ -311,25 +315,27 @@
va_list * const arg = (va_list *)(obj->data);
switch (size) {
- case SIZE_SHORT:
+ case SIZE_SHORT:
/* float is promoted to double */
return (HUGEFLOATVAL)(float)va_arg(*arg, double);
- case SIZE_REG:
+ case SIZE_REG:
return (HUGEFLOATVAL)(double)va_arg(*arg, double);
- case SIZE_HUGE:
+ case SIZE_HUGE:
return (HUGEFLOATVAL)(HUGEFLOATVAL) va_arg(*arg, HUGEFLOATVAL);
- case SIZE_XVAL:
+ case SIZE_XVAL:
return (HUGEFLOATVAL)(FLOATVAL) va_arg(*arg, FLOATVAL);
- case SIZE_PMC:{
+ case SIZE_PMC:
+ {
PMC * const pmc = (PMC *)va_arg(*arg, PMC *);
return (HUGEFLOATVAL)(VTABLE_get_number(interp, pmc));
}
- default:
+
+ default:
Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_INVALID_CHARACTER,
"Internal sprintf doesn't recognize size %d for a float", size);
}
@@ -476,14 +482,14 @@
ret = VTABLE_get_integer(interp, tmp);
switch (size) {
- case SIZE_SHORT:
+ case SIZE_SHORT:
ret = (short)ret;
break;
/* case SIZE_REG: ret=(HUGEINTVAL)(int)ret; break; */
- case SIZE_LONG:
+ case SIZE_LONG:
ret = (long)ret;
break;
- default:
+ default:
/* nothing */ ;
}
@@ -516,14 +522,14 @@
ret = (UINTVAL)VTABLE_get_integer(interp, tmp);
switch (size) {
- case SIZE_SHORT:
+ case SIZE_SHORT:
ret = (unsigned short)ret;
break;
/* case SIZE_REG: * ret=(UHUGEINTVAL)(unsigned int)ret; * break; */
- case SIZE_LONG:
+ case SIZE_LONG:
ret = (unsigned long)ret;
break;
- default:
+ default:
/* nothing */ ;
}
Modified: trunk/src/string/api.c
==============================================================================
--- trunk/src/string/api.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/string/api.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -2138,45 +2138,45 @@
break;
switch (state) {
- case parse_start:
- if (isdigit((unsigned char)c)) {
- const INTVAL nextval = c - '0';
- if (i < max_safe || (i == max_safe && nextval <= last_dig))
- i = i * 10 + nextval;
- else
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_ERR_OVERFLOW,
- "Integer value of String '%S' too big", s);
- state = parse_before_dot;
- }
- else if (c == '-') {
- sign = -1;
- state = parse_before_dot;
- }
- else if (c == '+')
- state = parse_before_dot;
- else if (isspace((unsigned char)c))
- ; /* Do nothing */
+ case parse_start:
+ if (isdigit((unsigned char)c)) {
+ const INTVAL nextval = c - '0';
+ if (i < max_safe || (i == max_safe && nextval <= last_dig))
+ i = i * 10 + nextval;
else
- state = parse_end;
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_ERR_OVERFLOW,
+ "Integer value of String '%S' too big", s);
+ state = parse_before_dot;
+ }
+ else if (c == '-') {
+ sign = -1;
+ state = parse_before_dot;
+ }
+ else if (c == '+')
+ state = parse_before_dot;
+ else if (isspace((unsigned char)c))
+ ; /* Do nothing */
+ else
+ state = parse_end;
- break;
+ break;
- case parse_before_dot:
- if (isdigit((unsigned char)c)) {
- const INTVAL nextval = c - '0';
- if (i < max_safe || (i == max_safe && nextval <= last_dig))
- i = i * 10 + nextval;
- else
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_ERR_OVERFLOW,
- "Integer value of String '%S' too big", s);
- }
+ case parse_before_dot:
+ if (isdigit((unsigned char)c)) {
+ const INTVAL nextval = c - '0';
+ if (i < max_safe || (i == max_safe && nextval <= last_dig))
+ i = i * 10 + nextval;
else
- state = parse_end;
- break;
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_ERR_OVERFLOW,
+ "Integer value of String '%S' too big", s);
+ }
+ else
+ state = parse_end;
+ break;
- default:
- /* Pacify compiler */
- break;
+ default:
+ /* Pacify compiler */
+ break;
}
}
@@ -2233,100 +2233,100 @@
break;
switch (state) {
- case parse_start:
- if (isdigit((unsigned char)c)) {
- f = c - '0';
- m = c - '0';
- state = parse_before_dot;
- }
- else if (c == '-') {
- sign = -1.0;
- state = parse_before_dot;
- }
- else if (c == '+')
- state = parse_before_dot;
- else if (c == '.')
- state = parse_after_dot;
- else if (isspace((unsigned char)c))
- ; /* Do nothing */
- else {
- check_nan = 1;
- state = parse_end;
- }
- break;
+ case parse_start:
+ if (isdigit((unsigned char)c)) {
+ f = c - '0';
+ m = c - '0';
+ state = parse_before_dot;
+ }
+ else if (c == '-') {
+ sign = -1.0;
+ state = parse_before_dot;
+ }
+ else if (c == '+')
+ state = parse_before_dot;
+ else if (c == '.')
+ state = parse_after_dot;
+ else if (isspace((unsigned char)c))
+ ; /* Do nothing */
+ else {
+ check_nan = 1;
+ state = parse_end;
+ }
+ break;
- case parse_before_dot:
- if (isdigit((unsigned char)c)) {
- f = f*10.0 + (c-'0');
- m = m*10 + (c-'0');
- /* Integer overflow for mantissa */
- if (m >= max_safe)
- m_is_safe = 0;
- }
- else if (c == '.') {
- state = parse_after_dot;
- /*
- * Throw gathered result. Recalulate from integer mantissa
- * to preserve precision.
- */
- if (m_is_safe)
- f = m;
- mantissa = f;
- }
- else if (c == 'e' || c == 'E') {
- state = parse_after_e;
- /* See comment above */
- if (m_is_safe)
- f = m;
- mantissa = f;
- }
- else {
- check_nan = 1;
- state = parse_end;
- }
- break;
+ case parse_before_dot:
+ if (isdigit((unsigned char)c)) {
+ f = f*10.0 + (c-'0');
+ m = m*10 + (c-'0');
+ /* Integer overflow for mantissa */
+ if (m >= max_safe)
+ m_is_safe = 0;
+ }
+ else if (c == '.') {
+ state = parse_after_dot;
+ /*
+ * Throw gathered result. Recalulate from integer mantissa
+ * to preserve precision.
+ */
+ if (m_is_safe)
+ f = m;
+ mantissa = f;
+ }
+ else if (c == 'e' || c == 'E') {
+ state = parse_after_e;
+ /* See comment above */
+ if (m_is_safe)
+ f = m;
+ mantissa = f;
+ }
+ else {
+ check_nan = 1;
+ state = parse_end;
+ }
+ break;
- case parse_after_dot:
- if (isdigit((unsigned char)c)) {
- f += (c-'0') * divider;
- divider /= 10.0;
- d = d*10 + (c-'0');
- if (d >= max_safe)
- d_is_safe = 0;
- d_length++;
- }
- else if (c == 'e' || c == 'E')
- state = parse_after_e;
- else
- state = parse_end;
- break;
+ case parse_after_dot:
+ if (isdigit((unsigned char)c)) {
+ f += (c-'0') * divider;
+ divider /= 10.0;
+ d = d*10 + (c-'0');
+ if (d >= max_safe)
+ d_is_safe = 0;
+ d_length++;
+ }
+ else if (c == 'e' || c == 'E')
+ state = parse_after_e;
+ else
+ state = parse_end;
+ break;
- case parse_after_e:
- if (isdigit((unsigned char)c)) {
- e = e*10 + (c-'0');
- state = parse_after_e_sign;
- }
- else if (c == '-') {
- e_sign = -1;
- state = parse_after_e_sign;
- }
- else if (c == '+')
- state = parse_after_e_sign;
- else
- state = parse_end;
- break;
+ case parse_after_e:
+ if (isdigit((unsigned char)c)) {
+ e = e*10 + (c-'0');
+ state = parse_after_e_sign;
+ }
+ else if (c == '-') {
+ e_sign = -1;
+ state = parse_after_e_sign;
+ }
+ else if (c == '+')
+ state = parse_after_e_sign;
+ else
+ state = parse_end;
+ break;
- case parse_after_e_sign:
- if (isdigit((unsigned char)c))
- e = e*10 + (c-'0');
- else
- state = parse_end;
- break;
+ case parse_after_e_sign:
+ if (isdigit((unsigned char)c))
+ e = e*10 + (c-'0');
+ else
+ state = parse_end;
+ break;
- case parse_end:
- default:
- /* Pacify compiler */
- break;
+ case parse_end:
+ default:
+ /* Pacify compiler */
+ break;
}
}
@@ -2707,43 +2707,43 @@
dp = (unsigned char *)result->strstart;
}
switch (c) {
- case '\\':
- dp[i++] = '\\';
- break;
- case '\a':
- dp[i++] = '\\';
- c = 'a';
- break;
- case '\b':
- dp[i++] = '\\';
- c = 'b';
- break;
- case '\n':
- dp[i++] = '\\';
- c = 'n';
- break;
- case '\r':
- dp[i++] = '\\';
- c = 'r';
- break;
- case '\t':
- dp[i++] = '\\';
- c = 't';
- break;
- case '\f':
- dp[i++] = '\\';
- c = 'f';
- break;
- case '"':
- dp[i++] = '\\';
- c = '"';
- break;
- case 27:
- dp[i++] = '\\';
- c = 'e';
- break;
- default:
- break;
+ case '\\':
+ dp[i++] = '\\';
+ break;
+ case '\a':
+ dp[i++] = '\\';
+ c = 'a';
+ break;
+ case '\b':
+ dp[i++] = '\\';
+ c = 'b';
+ break;
+ case '\n':
+ dp[i++] = '\\';
+ c = 'n';
+ break;
+ case '\r':
+ dp[i++] = '\\';
+ c = 'r';
+ break;
+ case '\t':
+ dp[i++] = '\\';
+ c = 't';
+ break;
+ case '\f':
+ dp[i++] = '\\';
+ c = 'f';
+ break;
+ case '"':
+ dp[i++] = '\\';
+ c = '"';
+ break;
+ case 27:
+ dp[i++] = '\\';
+ c = 'e';
+ break;
+ default:
+ break;
}
if (c >= 0x20) {
dp[i++] = (unsigned char)c;
@@ -3430,8 +3430,8 @@
VTABLE_set_integer_native(interp, res, slen);
for (i = 0; i < slen; ++i) {
- STRING * const p = Parrot_str_substr(interp, str, i, 1, NULL, 0);
- VTABLE_set_string_keyed_int(interp, res, i, p);
+ STRING * const p = Parrot_str_substr(interp, str, i, 1, NULL, 0);
+ VTABLE_set_string_keyed_int(interp, res, i, p);
}
return res;
Modified: trunk/src/string/primitives.c
==============================================================================
--- trunk/src/string/primitives.c Sun Dec 6 14:47:19 2009 (r42916)
+++ trunk/src/string/primitives.c Sun Dec 6 14:56:10 2009 (r42917)
@@ -95,54 +95,90 @@
++*offset;
switch (codepoint) {
- case 'x':
+ case 'x':
+ codepoint = CHARSET_GET_BYTE(interp, string, *offset);
+ if (codepoint >= '0' && codepoint <= '9') {
+ workchar = codepoint - '0';
+ }
+ else if (codepoint >= 'a' && codepoint <= 'f') {
+ workchar = codepoint - 'a' + 10;
+ }
+ else if (codepoint >= 'A' && codepoint <= 'F') {
+ workchar = codepoint - 'A' + 10;
+ }
+ else if (codepoint == '{') {
+ int i;
+ ++*offset;
+ workchar = 0;
+ for (i = 0; i < 8 && *offset < len; ++i, ++*offset) {
+ codepoint = CHARSET_GET_BYTE(interp, string, *offset);
+ if (codepoint == '}') {
+ ++*offset;
+ return workchar;
+ }
+ workchar *= 16;
+ if (codepoint >= '0' && codepoint <= '9') {
+ workchar += codepoint - '0';
+ }
+ else if (codepoint >= 'a' && codepoint <= 'f') {
+ workchar += codepoint - 'a' + 10;
+ }
+ else if (codepoint >= 'A' && codepoint <= 'F') {
+ workchar += codepoint - 'A' + 10;
+ }
+ else {
+ Parrot_ex_throw_from_c_args(interp, NULL,
+ EXCEPTION_UNIMPLEMENTED,
+ "Illegal escape sequence inside {}");
+ }
+ }
+ if (*offset == len)
+ Parrot_ex_throw_from_c_args(interp, NULL,
+ EXCEPTION_UNIMPLEMENTED,
+ "Illegal escape sequence no '}'");
+ }
+ else {
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
+ "Illegal escape sequence in");
+ }
+
+ ++*offset;
+ if (*offset < len) {
+ workchar *= 16;
codepoint = CHARSET_GET_BYTE(interp, string, *offset);
if (codepoint >= '0' && codepoint <= '9') {
- workchar = codepoint - '0';
+ workchar += codepoint - '0';
}
else if (codepoint >= 'a' && codepoint <= 'f') {
- workchar = codepoint - 'a' + 10;
+ workchar += codepoint - 'a' + 10;
}
else if (codepoint >= 'A' && codepoint <= 'F') {
- workchar = codepoint - 'A' + 10;
- }
- else if (codepoint == '{') {
- int i;
- ++*offset;
- workchar = 0;
- for (i = 0; i < 8 && *offset < len; ++i, ++*offset) {
- codepoint = CHARSET_GET_BYTE(interp, string, *offset);
- if (codepoint == '}') {
- ++*offset;
- return workchar;
- }
- workchar *= 16;
- if (codepoint >= '0' && codepoint <= '9') {
- workchar += codepoint - '0';
- }
- else if (codepoint >= 'a' && codepoint <= 'f') {
- workchar += codepoint - 'a' + 10;
- }
- else if (codepoint >= 'A' && codepoint <= 'F') {
- workchar += codepoint - 'A' + 10;
- }
- else {
- Parrot_ex_throw_from_c_args(interp, NULL,
- EXCEPTION_UNIMPLEMENTED,
- "Illegal escape sequence inside {}");
- }
- }
- if (*offset == len)
- Parrot_ex_throw_from_c_args(interp, NULL,
- EXCEPTION_UNIMPLEMENTED,
- "Illegal escape sequence no '}'");
+ workchar += codepoint - 'A' + 10;
}
else {
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
- "Illegal escape sequence in");
+ return workchar;
}
+ }
+ else {
+ return workchar;
+ }
+ ++*offset;
+ return workchar;
+ case 'c':
+ codepoint = CHARSET_GET_BYTE(interp, string, *offset);
+ if (codepoint >= 'A' && codepoint <= 'Z') {
+ workchar = codepoint - 'A' + 1;
+ }
+ else {
+ Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
+ "Illegal escape sequence");
+ }
- ++*offset;
+ ++*offset;
+ return workchar;
+ case 'u':
+ workchar = 0;
+ for (charcount = 0; charcount < 4; charcount++) {
if (*offset < len) {
workchar *= 16;
codepoint = CHARSET_GET_BYTE(interp, string, *offset);
@@ -156,146 +192,110 @@
workchar += codepoint - 'A' + 10;
}
else {
- return workchar;
+ Parrot_ex_throw_from_c_args(interp, NULL,
+ EXCEPTION_UNIMPLEMENTED,
+ "Illegal escape sequence in uxxx escape");
}
}
else {
- return workchar;
- }
- ++*offset;
- return workchar;
- case 'c':
- codepoint = CHARSET_GET_BYTE(interp, string, *offset);
- if (codepoint >= 'A' && codepoint <= 'Z') {
- workchar = codepoint - 'A' + 1;
- }
- else {
- Parrot_ex_throw_from_c_args(interp, NULL, EXCEPTION_UNIMPLEMENTED,
- "Illegal escape sequence");
+ Parrot_ex_throw_from_c_args(interp, NULL,
+ EXCEPTION_UNIMPLEMENTED,
+ "Illegal escape sequence in uxxx escape - too short");
}
++*offset;
- return workchar;
- case 'u':
- workchar = 0;
- for (charcount = 0; charcount < 4; charcount++) {
- if (*offset < len) {
- workchar *= 16;
- codepoint = CHARSET_GET_BYTE(interp, string, *offset);
- if (codepoint >= '0' && codepoint <= '9') {
- workchar += codepoint - '0';
- }
- else if (codepoint >= 'a' && codepoint <= 'f') {
- workchar += codepoint - 'a' + 10;
- }
- else if (codepoint >= 'A' && codepoint <= 'F') {
- workchar += codepoint - 'A' + 10;
- }
- else {
- Parrot_ex_throw_from_c_args(interp, NULL,
- EXCEPTION_UNIMPLEMENTED,
- "Illegal escape sequence in uxxx escape");
- }
+ }
+ return workchar;
+ case 'U':
+ workchar = 0;
+ for (charcount = 0; charcount < 8; charcount++) {
+ if (*offset < len) {
+ workchar *= 16;
+ codepoint = CHARSET_GET_BYTE(interp, string, *offset);
+ if (codepoint >= '0' && codepoint <= '9') {
+ workchar += codepoint - '0';
+ }
+ else if (codepoint >= 'a' && codepoint <= 'f') {
+ workchar += codepoint - 'a' + 10;
+ }
+ else if (codepoint >= 'A' && codepoint <= 'F') {
+ workchar += codepoint - 'A' + 10;
}
else {
Parrot_ex_throw_from_c_args(interp, NULL,
- EXCEPTION_UNIMPLEMENTED,
- "Illegal escape sequence in uxxx escape - too short");
- }
-
- ++*offset;
- }
- return workchar;
- case 'U':
- workchar = 0;
- for (charcount = 0; charcount < 8; charcount++) {
- if (*offset < len) {
- workchar *= 16;
- codepoint = CHARSET_GET_BYTE(interp, string, *offset);
- if (codepoint >= '0' && codepoint <= '9') {
- workchar += codepoint - '0';
- }
- else if (codepoint >= 'a' && codepoint <= 'f') {
- workchar += codepoint - 'a' + 10;
- }
- else if (codepoint >= 'A' && codepoint <= 'F') {
- workchar += codepoint - 'A' + 10;
- }
- else {
- Parrot_ex_throw_from_c_args(interp, NULL,
EXCEPTION_UNIMPLEMENTED,
"Illegal escape sequence in Uxxx escape");
- }
}
- else {
- Parrot_ex_throw_from_c_args(interp, NULL,
+ }
+ else {
+ Parrot_ex_throw_from_c_args(interp, NULL,
EXCEPTION_UNIMPLEMENTED,
"Illegal escape sequence in uxxx escape - too short");
- }
-
- ++*offset;
}
- return workchar;
- case '0':
- case '1':
- case '2':
- case '3':
- case '4':
- case '5':
- case '6':
- case '7':
- workchar = codepoint - '0';
- if (*offset < len) {
- workchar *= 8;
- codepoint = CHARSET_GET_BYTE(interp, string, *offset);
- if (codepoint >= '0' && codepoint <= '7') {
- workchar += codepoint - '0';
- }
- else {
- return workchar;
- }
+
+ ++*offset;
+ }
+ return workchar;
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7':
+ workchar = codepoint - '0';
+ if (*offset < len) {
+ workchar *= 8;
+ codepoint = CHARSET_GET_BYTE(interp, string, *offset);
+ if (codepoint >= '0' && codepoint <= '7') {
+ workchar += codepoint - '0';
}
else {
return workchar;
}
- ++*offset;
- if (*offset < len) {
- workchar *= 8;
- codepoint = CHARSET_GET_BYTE(interp, string, *offset);
- if (codepoint >= '0' && codepoint <= '7') {
- workchar += codepoint - '0';
- }
- else {
- return workchar;
- }
+ }
+ else {
+ return workchar;
+ }
+ ++*offset;
+ if (*offset < len) {
+ workchar *= 8;
+ codepoint = CHARSET_GET_BYTE(interp, string, *offset);
+ if (codepoint >= '0' && codepoint <= '7') {
+ workchar += codepoint - '0';
}
else {
return workchar;
}
- ++*offset;
+ }
+ else {
return workchar;
- case 'a':
- return 7; /* bell */
- case 'b':
- return 8; /* bs */
- case 't':
- return 9;
- case 'n':
- return 10;
- case 'v':
- return 11;
- case 'f':
- return 12;
- case 'r':
- return 13;
- case 'e':
- return 27;
- case 92: /* \ */
- return 92;
- case '"':
- return '"';
- default:
- return codepoint; /* any not special return the char */
+ }
+ ++*offset;
+ return workchar;
+ case 'a':
+ return 7; /* bell */
+ case 'b':
+ return 8; /* bs */
+ case 't':
+ return 9;
+ case 'n':
+ return 10;
+ case 'v':
+ return 11;
+ case 'f':
+ return 12;
+ case 'r':
+ return 13;
+ case 'e':
+ return 27;
+ case 92: /* \ */
+ return 92;
+ case '"':
+ return '"';
+ default:
+ return codepoint; /* any not special return the char */
}
}
More information about the parrot-commits
mailing list