/*--------------------------------------------------------*/
void AzsSvrg::train_test_classif(const char *param,
const AzDSmat *_m_trn_x, const AzIntArr *_ia_trn_lab,
const AzDSmat *_m_tst_x, const AzIntArr *_ia_tst_lab,
int _class_num)
{
/*--- set data info into class variables so that everyone can see ... ---*/
m_trn_x = _m_trn_x; ia_trn_lab = _ia_trn_lab;
m_tst_x = _m_tst_x; ia_tst_lab = _ia_tst_lab;
v_trn_y = v_tst_y = NULL;
class_num = _class_num;
if (class_num == 2) {
AzTimeLog::print("Binary classification ... ", log_out);
class_num = 1;
}
/*--- parse parameters ---*/
AzParam azp(param);
resetParam(azp);
printParam(log_out);
azp.check(log_out);
/*--- training and testing ---*/
_train_test();
}
virtual void reset_data(const AzOut &out,
const AzSmat *m_data,
AzParam &p,
bool beTight,
const AzSvFeatInfo *inp_feat=NULL)
{
resetParam(p);
printParam(out);
/*--- count nonzero components ---*/
double nz_ratio;
m_data->nonZeroNum(&nz_ratio);
AzBytArr s("Training data: ");
s.cn(m_data->rowNum());s.c("x");s.cn(m_data->colNum());
s.c(", nonzero_ratio=", nz_ratio, 4);
/*--- decide sparse or dense ---*/
AzBytArr s_dp("; managed as dense data");
bool doSparse = false;
if (dataproc == dataproc_Auto &&
nz_ratio < Az_nz_ratio_threshold ||
dataproc == dataproc_Sparse) {
doSparse = true;
s_dp.reset("; managed as sparse data");
}
if (dataproc != dataproc_Auto) s_dp.concat(" as requested.");
else s_dp.concat(".");
AzPrint::writeln(out, "-------------");
AzPrint::writeln(out, s, s_dp);
AzPrint::writeln(out, "-------------");
/*--- pre-sort data ---*/
m_tran_sparse.reset();
m_tran_dense.unlock();
m_tran_dense.reset();
data_num = m_data->colNum();
if (doSparse) {
m_data->transpose(&m_tran_sparse);
sorted_arr.reset_sparse(&m_tran_sparse, beTight);
}
else {
m_tran_dense.transpose_from(m_data);
sorted_arr.reset_dense(&m_tran_dense, beTight);
/* prohibit any action to change the pointers to the column vectors */
m_tran_dense.lock();
}
if (inp_feat != NULL) {
feat.reset(inp_feat);
if (feat.featNum() != m_data->rowNum()) {
throw new AzException(AzInputError, "AzDataForTrTree::reset", "#feat mismatch");
}
}
else {
feat.reset(m_data->rowNum());
}
}
/*--------------------------------------------------------*/
void AzOptOnTree::reset(AzLossType l_type,
const AzDvect *inp_v_y,
const AzDvect *inp_v_fixed_dw, /* user-assigned data point weights */
const AzRegDepth *inp_reg_depth,
AzParam ¶m,
bool beVerbose,
const AzOut out_req,
/*--- for warm start ---*/
const AzTrTreeEnsemble_ReadOnly *inp_ens,
const AzTrTreeFeat *inp_tree_feat,
const AzDvect *inp_v_p)
{
_reset();
reg_depth = inp_reg_depth;
out = out_req;
my_dmp_out = dmp_out;
v_y.set(inp_v_y);
if (!AzDvect::isNull(inp_v_fixed_dw)) {
v_fixed_dw.set(inp_v_fixed_dw);
}
v_p.reform(v_y.rowNum());
loss_type = l_type;
resetParam(param);
if (max_delta < 0 &&
AzLoss::isExpoFamily(loss_type)) {
max_delta = 1;
}
printParam(out, beVerbose);
checkParam();
if (!beVerbose) {
out.deactivate();
my_dmp_out.deactivate();
}
var_const = 0;
fixed_const = 0;
if (doUseAvg) {
fixed_const = v_y.sum() / (double)v_y.rowNum();
v_p.set(fixed_const);
}
if (inp_ens != NULL) {
_warmup(inp_ens, inp_tree_feat, inp_v_p);
}
}
string SymbolNode::print()
{
string s = printParam();
s += ", nesting level ";
s += to_string(nestingLevel);
if (parameterTop != NULL)
{
s += "\n\tparam-list:";
SymbolNode *p = parameterTop;
while (p != NULL)
{
s += "\n\t" + p->printParam();
p = p->next;
}
}
return s;
}
virtual void reset(int argc, const char *argv[], const AzOut &out) {
if (argc < 2) {
if (argc >= 1) {
AzPrint::writeln(out, "");
AzPrint::writeln(out, argv[0]); /* action */
}
printHelp(out);
throw new AzException(AzNormal, "", "");
}
const char *action = argv[0];
AzParam azp(param_dlm, argc-1, argv+1);
AzPrint::writeln(out, "");
AzPrint::writeln(out, "--------------------------------------------------");
AzPrint::writeln(out, action, " ", azp.c_str());
AzPrint::writeln(out, "--------------------------------------------------");
resetParam(azp);
printParam(out);
azp.check(out);
}
/*--------------------------------------------------------*/
void AzsSvrg::train_test_regress(const char *param,
const AzDSmat *_m_trn_x, const AzDvect *_v_trn_y,
const AzDSmat *_m_tst_x, const AzDvect *_v_tst_y)
{
/*--- set data info into class variables so that everyone can see ... ---*/
m_trn_x = _m_trn_x; v_trn_y = _v_trn_y;
m_tst_x = _m_tst_x; v_tst_y = _v_tst_y;
ia_trn_lab = ia_tst_lab = NULL;
class_num = 1;
AzTimeLog::print("Regression ... ", log_out);
/*--- parse parameters ---*/
AzParam azp(param);
resetParam(azp);
printParam(log_out);
azp.check(log_out);
/*--- training and testing ---*/
_train_test();
}
/*------------------------------------------------------------------*/
void AzTrTreeFeat::reset(const AzDataForTrTree *data,
AzParam ¶m,
const AzOut &out_req,
bool inp_doAllowZeroWeightLeaf)
{
out = out_req;
org_featInfo.reset(data->featInfo());
ip_featDef.reset();
int init_size=10000, avg_len=32;
pool_rules.reset(init_size, avg_len);
pool_rules_rmved.reset(init_size, avg_len);
sp_desc.reset(init_size, avg_len);
f_inf.reset();
doAllowZeroWeightLeaf = inp_doAllowZeroWeightLeaf;
bool beVerbose = resetParam(param);
printParam(out);
if (!beVerbose) {
out.deactivate();
}
}
BOOLEAN OtrosMenu(void)
{
int select = 0;
while(TRUE)
{
select = MenuSelect(&OtroMenu, select);
if (select == -1)
return FALSE;
switch (select)
{
case 1:
verVersionSyspack();
break;
case 2:
printParam();
break;
}
}
return TRUE;
}
void doHandlePlayerType( const PlayerTypeT & type )
{
std::cout << "<PlayerType id=\"" << type.id_ << "\">\n";
printParam( "player_speed_max", type.player_speed_max_ );
printParam( "stamina_inc_max", type.stamina_inc_max_ );
printParam( "player_decay", type.player_decay_ );
printParam( "inertia_moment", type.inertia_moment_ );
printParam( "dash_power_rate", type.dash_power_rate_ );
printParam( "player_size", type.player_size_ );
printParam( "kickable_margin", type.kickable_margin_ );
printParam( "kick_rand", type.kick_rand_ );
printParam( "extra_stamina", type.extra_stamina_ );
printParam( "effort_max", type.effort_max_ );
printParam( "effort_min", type.effort_min_ );
// 14.0.0
printParam( "kick_power_rate", type.kick_power_rate_ );
printParam( "foul_detect_probability", type.foul_detect_probability_ );
printParam( "catchable_area_l_stretch", type.catchable_area_l_stretch_ );
std::cout << "</PlayerType>\n";
}
void doHandlePlayerParam( const PlayerParamT & param )
{
std::cout << "<PlayerParam>\n";
printParam( "player_types", param.player_types_ );
printParam( "subs_max", param.subs_max_ );
printParam( "pt_max", param.pt_max_ );
printParam( "allow_mult_default_type", param.player_speed_max_delta_min_ );
printParam( "player_speed_max_delta_min", param.player_speed_max_delta_min_ );
printParam( "player_speed_max_delta_max", param.player_speed_max_delta_max_ );
printParam( "stamina_inc_max_delta_factor", param.stamina_inc_max_delta_factor_ );
printParam( "player_decay_delta_min", param.player_decay_delta_min_ );
printParam( "player_decay_delta_max", param.player_decay_delta_max_ );
printParam( "inertia_moment_delta_factor", param.inertia_moment_delta_factor_ );
printParam( "dash_power_rate_delta_min", param.dash_power_rate_delta_min_ );
printParam( "dash_power_rate_delta_max", param.dash_power_rate_delta_max_ );
printParam( "player_size_delta_factor", param.player_size_delta_factor_ );
printParam( "kickable_margin_delta_min", param.kickable_margin_delta_min_ );
printParam( "kickable_margin_delta_max", param.kickable_margin_delta_max_ );
printParam( "kick_rand_delta_factor", param.kick_rand_delta_factor_ );
printParam( "extra_stamina_delta_min", param.extra_stamina_delta_min_ );
printParam( "extra_stamina_delta_max", param.extra_stamina_delta_max_ );
printParam( "effort_max_delta_factor", param.effort_max_delta_factor_ );
printParam( "effort_min_delta_factor", param.effort_min_delta_factor_ );
printParam( "random_seed", param.random_seed_ );
printParam( "new_dash_power_rate_delta_min", param.new_dash_power_rate_delta_min_ );
printParam( "new_dash_power_rate_delta_max", param.new_dash_power_rate_delta_max_ );
printParam( "new_stamina_inc_max_delta_factor", param.new_stamina_inc_max_delta_factor_ );
// 14.0.0
printParam( "kick_power_rate_delta_min", param.kick_power_rate_delta_min_ );
printParam( "kick_power_rate_delta_max", param.kick_power_rate_delta_max_ );
printParam( "foul_detect_probability_delta_factor", param.foul_detect_probability_delta_factor_ );
printParam( "catchable_area_l_stretch_min", param.catchable_area_l_stretch_min_ );
printParam( "catchable_area_l_stretch_max", param.catchable_area_l_stretch_max_ );
std::cout << "</PlayerParam>\n";
}
void doHandleServerParam( const ServerParamT & param )
{
std::cout << "<ServerParam>\n";
printParam( "goal_width", param.goal_width_ );
printParam( "inertia_moment", param.inertia_moment_ );
printParam( "player_size", param.player_size_ );
printParam( "player_decay", param.player_decay_ );
printParam( "player_rand", param.player_rand_ );
printParam( "player_weight", param.player_weight_ );
printParam( "player_speed_max", param.player_speed_max_ );
printParam( "player_accel_max", param.player_accel_max_ );
printParam( "stamina_max", param.stamina_max_ );
printParam( "stamina_inc_max", param.stamina_inc_max_ );
printParam( "recover_init", param.recover_init_ );
printParam( "recover_dec_thr", param.recover_dec_thr_ );
printParam( "recover_min", param.recover_min_ );
printParam( "recover_dec", param.recover_dec_ );
printParam( "effort_init", param.effort_init_ );
printParam( "effort_dec_thr", param.effort_dec_thr_ );
printParam( "effort_min", param.effort_min_ );
printParam( "effort_dec", param.effort_dec_ );
printParam( "effort_inc_thr", param.effort_inc_thr_ );
printParam( "effort_inc", param.effort_inc_ );
printParam( "kick_rand", param.kick_rand_ );
printParam( "team_actuator_noise", param.team_actuator_noise_ );
printParam( "prand_factor_l", param.player_rand_factor_l_ );
printParam( "prand_factor_r", param.player_rand_factor_r_ );
printParam( "kick_rand_factor_l", param.kick_rand_factor_l_ );
printParam( "kick_rand_factor_r", param.kick_rand_factor_r_ );
printParam( "ball_size", param.ball_size_ );
printParam( "ball_decay", param.ball_decay_ );
printParam( "ball_rand", param.ball_rand_ );
printParam( "ball_weight", param.ball_weight_ );
printParam( "ball_speed_max", param.ball_speed_max_ );
printParam( "ball_accel_max", param.ball_accel_max_ );
printParam( "dash_power_rate", param.dash_power_rate_ );
printParam( "kick_power_rate", param.kick_power_rate_ );
printParam( "kickable_margin", param.kickable_margin_ );
printParam( "control_radius", param.control_radius_ );
//printParam( "control_radius_width", param.control_radius_width_ );
//printParam( "kickable_area", param.kickable_area_ );
printParam( "catch_probability", param.catch_probability_ );
printParam( "catchable_area_l", param.catchable_area_l_ );
printParam( "catchable_area_w", param.catchable_area_w_ );
printParam( "goalie_max_moves", param.goalie_max_moves_ );
printParam( "maxpower", param.max_power_ );
printParam( "minpower", param.min_power_ );
printParam( "maxmoment", param.max_moment_ );
printParam( "minmoment", param.min_moment_ );
printParam( "maxneckmoment", param.max_neck_moment_ );
printParam( "minneckmoment", param.min_neck_moment_ );
printParam( "maxneckang", param.max_neck_angle_ );
printParam( "minneckang", param.min_neck_angle_ );
printParam( "visible_angle", param.visible_angle_ );
printParam( "visible_distance", param.visible_distance_ );
printParam( "audio_cut_dist", param.audio_cut_dist_ );
printParam( "quantize_step", param.quantize_step_ );
printParam( "quantize_step_l", param.landmark_quantize_step_ );
//printParam( "dir_qstep", param.dir_quantize_step );
//printParam( "dist_qstep_l", param.dist_quantize_step_l );
//printParam( "dist_qstep_r", param.dist_quantize_step_r );
//printParam( "land_qstep_l", param.landmark_dist_quantize_step_l );
//printParam( "land_qstep_r", param.landmark_dist_quantize_step_r );
//printParam( "dir_qstep_l", param.dir_quantize_step_l_ );
//printParam( "dir_qstep_r", param.dir_quantize_step_r );
printParam( "ckick_margin", param.corner_kick_margin_ );
printParam( "wind_dir", param.wind_dir_ );
printParam( "wind_force", param.wind_force_ );
printParam( "wind_ang", param.wind_angle_ );
printParam( "wind_rand", param.wind_rand_ );
printParam( "wind_none", param.wind_none_ );
printParam( "wind_random", param.wind_random_ );
printParam( "half_time", param.half_time_ );
printParam( "drop_ball_time", param.drop_ball_time_ );
printParam( "port", param.port_ );
printParam( "coach_port", param.coach_port_ );
printParam( "olcoach_port", param.online_coach_port_ );
printParam( "say_coach_cnt_max", param.say_coach_count_max_ );
printParam( "say_coach_msg_size", param.say_coach_msg_size_ );
printParam( "simulator_step", param.simulator_step_ );
printParam( "send_step", param.send_step_ );
printParam( "recv_step", param.recv_step_ );
printParam( "sense_body_step", param.sense_body_step_ );
//printParam( "lcm_step", param.lcm_step_ );
printParam( "say_msg_size", param.say_msg_size_ );
printParam( "clang_win_size", param.clang_win_size_ );
printParam( "clang_define_win", param.clang_define_win_ );
printParam( "clang_meta_win", param.clang_meta_win_ );
printParam( "clang_advice_win", param.clang_advice_win_ );
printParam( "clang_info_win", param.clang_info_win_ );
printParam( "clang_del_win", param.clang_del_win_ );
printParam( "clang_rule_win", param.clang_rule_win_ );
printParam( "clang_mess_delay", param.clang_mess_delay_ );
printParam( "clang_mess_per_cycle", param.clang_mess_per_cycle_ );
printParam( "hear_max", param.hear_max_ );
printParam( "hear_inc", param.hear_inc_ );
printParam( "hear_decay", param.hear_decay_ );
printParam( "catch_ban_cycle", param.catch_ban_cycle_ );
printParam( "coach", param.coach_mode_ );
printParam( "coach_w_referee", param.coach_with_referee_mode_ );
printParam( "old_coach_hear", param.old_coach_hear_ );
printParam( "send_vi_st", param.send_vi_step_ );
printParam( "use_offside", param.use_offside_ );
printParam( "offside_kick_margin", param.offside_kick_margin_ );
printParam( "forbid_kick_off_offside", param.forbid_kick_off_offside_ );
printParam( "verbose", param.verbose_ );
printParam( "offside_active_area_size", param.offside_active_area_size_ );
printParam( "slow_down_factor", param.slow_down_factor_ );
printParam( "synch_mode", param.synch_mode_ );//pfr:SYNCH
printParam( "synch_offset", param.synch_offset_ );//pfr:SYNCH
printParam( "synch_micro_sleep", param.synch_micro_sleep_ );//pfr:SYNCH
printParam( "start_goal_l", param.start_goal_l_ );
printParam( "start_goal_r", param.start_goal_r_ );
printParam( "fullstate_l", param.fullstate_l_ );
printParam( "fullstate_r", param.fullstate_r_ );
printParam( "slowness_on_top_for_left_team", param.slowness_on_top_for_left_team_ );
printParam( "slowness_on_top_for_right_team", param.slowness_on_top_for_left_team_ );
printParam( "landmark_file", param.landmark_file_ );
printParam( "send_comms", param.send_comms_ );
printParam( "text_logging", param.text_logging_ );
printParam( "game_logging", param.game_logging_ );
printParam( "game_log_version", param.game_log_version_ );
printParam( "text_log_dir", param.text_log_dir_ );
printParam( "game_log_dir", param.game_log_dir_ );
printParam( "text_log_fixed_name", param.text_log_fixed_name_ );
printParam( "game_log_fixed_name", param.game_log_fixed_name_ );
printParam( "text_log_fixed", param.text_log_fixed_ );
printParam( "game_log_fixed", param.game_log_fixed_ );
printParam( "text_log_dated", param.text_log_dated_ );
printParam( "game_log_dated", param.game_log_dated_ );
printParam( "log_date_format", param.log_date_format_ );
printParam( "log_times", param.log_times_ );
printParam( "record_messages", param.record_messages_ );
printParam( "text_log_compression", param.text_log_compression_ );
printParam( "game_log_compression", param.game_log_compression_ );
printParam( "profile", param.profile_ );
printParam( "point_to_ban", param.point_to_ban_ );
printParam( "point_to_duration", param.point_to_duration_ );
printParam( "tackle_dist", param.tackle_dist_ );
printParam( "tackle_back_dist", param.tackle_back_dist_ );
printParam( "tackle_width", param.tackle_width_ );
printParam( "tackle_exponent", param.tackle_exponent_ );
printParam( "tackle_cycles", param.tackle_cycles_ );
printParam( "tackle_power_rate", param.tackle_power_rate_ );
printParam( "freeform_wait_period", param.freeform_wait_period_ );
printParam( "freeform_send_period", param.freeform_send_period_ );
printParam( "free_kick_faults", param.free_kick_faults_ );
printParam( "back_passes", param.back_passes_ );
printParam( "proper_goal_kicks", param.proper_goal_kicks_ );
printParam( "stopped_ball_vel", param.stopped_ball_vel_ );
printParam( "max_goal_kicks", param.max_goal_kicks_ );
printParam( "auto_mode", param.auto_mode_ );
printParam( "kick_off_wait", param.kick_off_wait_ );
printParam( "connect_wait", param.connect_wait_ );
printParam( "game_over_wait", param.game_over_wait_ );
printParam( "team_l_start", param.team_l_start_ );
printParam( "team_r_start", param.team_r_start_ );
printParam( "keepaway", param.keepaway_mode_ );
printParam( "keepaway_length", param.keepaway_length_ );
printParam( "keepaway_width", param.keepaway_width_ );
printParam( "keepaway_logging", param.keepaway_logging_ );
printParam( "keepaway_log_dir", param.keepaway_log_dir_ );
printParam( "keepaway_log_fixed_name", param.keepaway_log_fixed_name_ );
printParam( "keepaway_log_fixed", param.keepaway_log_fixed_ );
printParam( "keepaway_log_dated", param.keepaway_log_dated_ );
printParam( "keepaway_start", param.keepaway_start_ );
printParam( "nr_normal_halfs", param.nr_normal_halfs_ );
printParam( "nr_extra_halfs", param.nr_extra_halfs_ );
printParam( "penalty_shoot_outs", param.penalty_shoot_outs_ );
printParam( "pen_before_setup_wait", param.pen_before_setup_wait_ );
printParam( "pen_setup_wait", param.pen_setup_wait_ );
printParam( "pen_ready_wait", param.pen_ready_wait_ );
printParam( "pen_taken_wait", param.pen_taken_wait_ );
printParam( "pen_nr_kicks", param.pen_nr_kicks_ );
printParam( "pen_max_extra_kicks", param.pen_max_extra_kicks_ );
printParam( "pen_dist_x", param.pen_dist_x_ );
printParam( "pen_random_winner", param.pen_random_winner_ );
printParam( "pen_max_goalie_dist_x", param.pen_max_goalie_dist_x_ );
printParam( "pen_allow_mult_kicks", param.pen_allow_mult_kicks_ );
printParam( "pen_coach_moves_players", param.pen_coach_moves_players_ );
printParam( "ball_stuck_area", param.ball_stuck_area_ );
printParam( "coach_msg_file", param.coach_msg_file_ );
printParam( "max_tackle_power", param.max_tackle_power_ );
printParam( "max_back_tackle_power", param.max_back_tackle_power_ );
printParam( "player_speed_max_min", param.player_speed_max_min_ );
printParam( "extra_stamina", param.extra_stamina_ );
printParam( "synch_see_offset", param.synch_see_offset_ );
printParam( "max_monitors", param.max_monitors_ );
// 14.0.0
printParam( "tackle_rand_factor", param.tackle_rand_factor_ );
printParam( "foul_detect_probability", param.foul_detect_probability_ );
printParam( "foul_exponent", param.foul_exponent_ );
printParam( "foul_cycles", param.foul_cycles_ );
printParam( "golden_goal", param.golden_goal_ );
//printParam( "min_catch_probability", param.min_catch_probability_ );
//printParam( "reliable_catch_area_l", param.reliable_catch_area_l_ );
std::cout << "</ServerParam>\n";
}
void ASTPrint( int lev, ASTNode node )
{
if (! node)
{
indent( lev ); ec_stderr_printf( "NULL" );
return;
}
/* Simplify our lives ... */
if (currentScope)
{
if (currentScope->type == PackageScope)
{
currentPackage = currentScope->target;
currentBytecode = EC_PACKAGECODE(currentScope->target);
} else
{
currentBytecode = currentScope->target;
}
currentLiteral = EC_COMPILEDLFRAME(currentBytecode);
}
switch ( node->type )
{
case nullType:
indent( lev ); ec_stderr_printf( "<nullType>" );
break;
case symbolType:
printSymbol( lev, node );
break;
case qualifiedSymbolType:
printQualifiedSymbol( lev, node );
break;
case constExprType:
printConstant( lev, node );
break;
case variableExprType:
printVariable( lev, node );
break;
case arrayConstructionExprType:
printArrayCons( lev, node );
break;
case hashConstructionExprType:
printHashCons( lev, node );
break;
case unaryExprType:
printUnary( lev, node );
break;
case binaryExprType:
printBinary( lev, node );
break;
case conditionalExprType:
printConditional( lev, node );
break;
case orExprType:
printOr( lev, node );
break;
case andExprType:
printAnd( lev, node );
break;
case assignExprType:
printAssign( lev, node );
break;
case simAssignExprType:
printSimAssign( lev, node );
break;
case arrayRefExprType:
printArrayRef( lev, node );
break;
case declNodeType:
printDecl( lev, node );
break;
case declAtomNodeType:
printDeclAtom( lev, node );
break;
case statementType:
printStatement( lev, node );
break;
case labeledStmtType:
printLabeledStmt( lev, node );
break;
case exprStmtType:
printExprStmt( lev, node );
break;
case ifStmtType:
printIf( lev, node );
break;
case whileStmtType:
printWhile( lev, node );
break;
case doStmtType:
printDo( lev, node );
break;
case forStmtType:
printFor( lev, node );
break;
case forInStmtType:
printForIn( lev, node );
break;
case breakStmtType:
printBreak( lev, node );
break;
case continueStmtType:
printContinue( lev, node );
break;
case gotoStmtType:
printGoto( lev, node );
break;
case tryStmtType:
printTry( lev, node );
break;
case catchStmtType:
printCatch( lev, node );
break;
case throwStmtType:
printThrow( lev, node );
break;
case importStmtType:
printImport( lev, node );
break;
case paramNodeType:
printParam( lev, node );
break;
case paramListType:
printParamList( lev, node );
break;
case callNodeType:
printCall( lev, node );
break;
case methodCallNodeType:
printMethodCall( lev, node );
break;
case stmtListType:
printStmtList( lev, node );
break;
case funcNodeType:
printFunction( lev, node );
break;
case returnNodeType:
printReturn( lev, node );
break;
case classNodeType:
printClass( lev, node );
break;
case methodNodeType:
printMethod( lev, node );
break;
case packageNodeType:
printPackage( lev, node );
break;
}
}
