History

memory system upgrade (part 1); scope-sensitive cleanup for each return statement; clarified reference counting semantics; function argument release for builtin functions; improved post-function call object cleanup; auto-reference-increment on returned objects from all builtin/imported functions; absyn tree printing for instruction dumping abysn2str(); Machine.refcount() and refcount printing for object references

Ge Wang committed 3 years ago

Commit beef6541 parent 2eec4e717 files · +835 −72Browse files

Showing the changes to src/core/chuck_parse.cpp (1 of 17 files). Show all

Unified · Split

src/core/chuck_parse.cpp+404−0
@@ -278,3 +278,407 @@ t_CKBOOL SyntaxQuery::parseLine( const std::string & line, SyntaxTokenList & tok · 277 unmodified lines
278278
279279 return TRUE;
280280 }
281+
282+
283+
284+
285+
286+//-----------------------------------------------------------------------------
287+// absyn to string functions
288+//-----------------------------------------------------------------------------
289+#include "chuck_type.h"
290+string absyn_exp2str( a_Exp exp, t_CKBOOL iterate = true );
291+string absyn_binary2str( a_Exp_Binary binary );
292+string absyn_unary2str( a_Exp_Unary unary );
293+string absyn_op2str( ae_Operator op );
294+string absyn_cast2str( a_Exp_Cast cast );
295+string absyn_postfix2str( a_Exp_Postfix postfix );
296+string absyn_dur2str( a_Exp_Dur dur );
297+string absyn_primary2str( a_Exp_Primary primary );
298+string absyn_array2str( a_Exp_Array array );
299+string absyn_func_call2str( a_Exp_Func_Call func_call );
300+string absyn_dot_member2str( a_Exp_Dot_Member dot_member );
301+string absyn_exp_if2str( a_Exp_If exp_if );
302+string absyn_decl2str( a_Exp_Decl decl );
303+
304+
305+
306+
307+//-----------------------------------------------------------------------------
308+// name: absyn2str()
309+// desc: convert abstract syntax exp to string
310+//-----------------------------------------------------------------------------
311+string absyn2str( a_Exp exp )
312+{
313+ return absyn_exp2str( exp ) + ";";
314+}
315+
316+
317+
318+
319+//-----------------------------------------------------------------------------
320+// name: absyn_exp2str()
321+// desc: convert abstract syntax exp to string
322+//-----------------------------------------------------------------------------
323+string absyn_exp2str( a_Exp exp, t_CKBOOL iterate )
324+{
325+ string str = "";
326+
327+ // loop over
328+ while( exp )
329+ {
330+ switch( exp->s_type )
331+ {
332+ case ae_exp_binary:
333+ str += absyn_binary2str( &exp->binary );
334+ break;
335+
336+ case ae_exp_unary:
337+ str += absyn_unary2str( &exp->unary );
338+ break;
339+
340+ case ae_exp_cast:
341+ str += absyn_cast2str( &exp->cast );
342+ break;
343+
344+ case ae_exp_postfix:
345+ str += absyn_postfix2str( &exp->postfix );
346+ break;
347+
348+ case ae_exp_dur:
349+ str += absyn_dur2str( &exp->dur );
350+ break;
351+
352+ case ae_exp_primary:
353+ str += absyn_primary2str( &exp->primary );
354+ break;
355+
356+ case ae_exp_array:
357+ str += absyn_array2str( &exp->array );
358+ break;
359+
360+ case ae_exp_func_call:
361+ str += absyn_func_call2str( &exp->func_call );
362+ break;
363+
364+ case ae_exp_dot_member:
365+ str += absyn_dot_member2str( &exp->dot_member );
366+ break;
367+
368+ case ae_exp_if:
369+ str += absyn_exp_if2str( &exp->exp_if );
370+ break;
371+
372+ case ae_exp_decl:
373+ str += absyn_decl2str( &exp->decl );
374+ break;
375+
376+ default:
377+ return "";
378+ }
379+
380+ // implicit cast
381+ if( exp->cast_to != NULL )
382+ break;
383+
384+ // break
385+ if( !iterate ) break;
386+
387+ // next
388+ exp = exp->next;
389+ // if more
390+ if( exp ) str += ", ";
391+ }
392+
393+ return str;
394+}
395+
396+
397+
398+
399+//-----------------------------------------------------------------------------
400+// name: absyn_op2str()
401+// desc: convert abstract syntax operator to string
402+//-----------------------------------------------------------------------------
403+string absyn_op2str( ae_Operator op )
404+{
405+ string str;
406+ // get operation string
407+ switch( op )
408+ {
409+ case ae_op_plus: str = "+"; break;
410+ case ae_op_plus_chuck: str = "+=>"; break;
411+ case ae_op_minus: str = "-"; break;
412+ case ae_op_minus_chuck: str = "-=>"; break;
413+ case ae_op_times: str = "*"; break;
414+ case ae_op_times_chuck: str = "*=>"; break;
415+ case ae_op_divide: str = "/"; break;
416+ case ae_op_divide_chuck: str = "/=>"; break;
417+ case ae_op_s_or: str = "|"; break;
418+ case ae_op_s_or_chuck: str = "|=>"; break;
419+ case ae_op_s_and: str = "&"; break;
420+ case ae_op_s_and_chuck: str = "&=>"; break;
421+ case ae_op_shift_left: str = "<<"; break;
422+ case ae_op_shift_left_chuck: str = "<<=>"; break;
423+ case ae_op_shift_right: str = ">>"; break;
424+ case ae_op_shift_right_chuck: str = ">>=>"; break;
425+ case ae_op_percent: str = "%"; break;
426+ case ae_op_percent_chuck: str = "%=>"; break;
427+ case ae_op_s_xor: str = "^"; break;
428+ case ae_op_s_xor_chuck: str = "^=>"; break;
429+ case ae_op_chuck: str = "=>"; break;
430+ case ae_op_unchuck: str = "=<"; break;
431+ case ae_op_upchuck: str = "=^"; break;
432+ case ae_op_at_chuck: str = "@=>"; break;
433+ case ae_op_s_chuck: str = ""; break;
434+ case ae_op_eq: str = "=="; break;
435+ case ae_op_neq: str = "!="; break;
436+ case ae_op_lt: str = "<"; break;
437+ case ae_op_le: str = "<="; break;
438+ case ae_op_gt: str = ">"; break;
439+ case ae_op_ge: str = ">="; break;
440+ case ae_op_and: str = "&&"; break;
441+ case ae_op_or: str = "||"; break;
442+ case ae_op_arrow_left: str = "<-"; break;
443+ case ae_op_arrow_right: str = "->"; break;
444+
445+ // unary
446+ case ae_op_plusplus: str = "++"; break;
447+ case ae_op_minusminus: str = "--"; break;
448+ case ae_op_tilda: str = "~"; break;
449+ case ae_op_exclamation: str = "!"; break;
450+ case ae_op_spork: str = "spork ~"; break;
451+ case ae_op_new: str = "new"; break;
452+
453+ // not used
454+ case ae_op_typeof: str = "typeof"; break;
455+ case ae_op_sizeof: str = "sizeof"; break;
456+ default: str = "[OP]"; break;
457+ }
458+ return str;
459+}
460+
461+
462+
463+
464+//-----------------------------------------------------------------------------
465+// name: absyn_binary2str()
466+// desc: convert abstract syntax binary to string
467+//-----------------------------------------------------------------------------
468+string absyn_binary2str( a_Exp_Binary binary )
469+{
470+ // (lhs OP rhs)
471+ return "(" + absyn_exp2str(binary->lhs)
472+ + absyn_op2str(binary->op)
473+ + absyn_exp2str(binary->rhs) + ")";
474+}
475+
476+
477+
478+
479+//-----------------------------------------------------------------------------
480+// name: absyn_unary2str()
481+// desc: convert abstract syntax unary to string
482+//-----------------------------------------------------------------------------
483+string absyn_unary2str( a_Exp_Unary unary )
484+{
485+ return absyn_op2str(unary->op) + " " + absyn_exp2str(unary->exp);
486+}
487+
488+
489+
490+
491+//-----------------------------------------------------------------------------
492+// name: absyn_cast2str()
493+// desc: convert abstract syntax cast to string
494+//-----------------------------------------------------------------------------
495+string absyn_cast2str( a_Exp_Cast cast )
496+{
497+ Chuck_Type * to = cast->self->type;
498+ return "$ " + to->name;
499+}
500+
501+
502+
503+
504+//-----------------------------------------------------------------------------
505+// name: absyn_cast2str()
506+// desc: convert abstract syntax cast to string
507+//-----------------------------------------------------------------------------
508+string absyn_postfix2str( a_Exp_Postfix postfix )
509+{
510+ return absyn_exp2str( postfix->exp ) + absyn_op2str( postfix->op );
511+}
512+
513+
514+
515+
516+//-----------------------------------------------------------------------------
517+// name: absyn_dur2str()
518+// desc: convert abstract syntax dur to string
519+//-----------------------------------------------------------------------------
520+string absyn_dur2str( a_Exp_Dur dur )
521+{
522+ return absyn_exp2str(dur->base) + "::" + absyn_exp2str(dur->unit);
523+}
524+
525+
526+
527+
528+//-----------------------------------------------------------------------------
529+// name: absyn_primary2str()
530+// desc: convert abstract syntax primary to string
531+//-----------------------------------------------------------------------------
532+string absyn_primary2str( a_Exp_Primary primary )
533+{
534+ string str;
535+
536+ // find out exp
537+ switch( primary->s_type )
538+ {
539+ case ae_primary_var: str = S_name(primary->var); break;
540+ case ae_primary_num: str = to_string(primary->num); break;
541+ case ae_primary_float: str = primary->fnum; break;
542+ case ae_primary_str: str = primary->str; break;
543+ case ae_primary_char: str = primary->chr; break;
544+ case ae_primary_array: str = "["+absyn_exp2str(primary->array->exp_list)+"]"; break;
545+ case ae_primary_complex: str = "#("+absyn_exp2str(primary->complex->re)+")"; break;
546+ case ae_primary_polar: str = "%("+absyn_exp2str(primary->polar->mod)+")"; break;
547+ case ae_primary_vec: str = "@("+absyn_exp2str(primary->vec->args)+")"; break;
548+ case ae_primary_exp: str = absyn_exp2str(primary->exp); break;
549+ case ae_primary_hack: str = "<<< " + absyn_exp2str(primary->exp) + " >>>"; break;
550+ case ae_primary_nil: str = "null"; break;
551+ default: str ="[PRIMARY]"; break;
552+ }
553+
554+ return str;
555+}
556+
557+
558+
559+
560+//-----------------------------------------------------------------------------
561+// name: absyn_array2str()
562+// desc: convert abstract syntax array to string
563+//-----------------------------------------------------------------------------
564+string absyn_array2str( a_Exp_Array array )
565+{
566+ string str;
567+
568+ t_CKUINT depth = 0;
569+ a_Array_Sub sub = NULL;
570+ t_CKBOOL is_str = FALSE;
571+
572+ // get the sub
573+ sub = array->indices;
574+ // expressions
575+ a_Exp e = sub->exp_list;
576+
577+ // base of the array
578+ str = absyn_exp2str(array->base);
579+
580+ // loop over
581+ while( e )
582+ {
583+ // each index
584+ str += "[" + absyn_exp2str(e,false) + "]";
585+ // advance
586+ e = e->next;
587+ }
588+
589+ return str;
590+}
591+
592+
593+
594+
595+//-----------------------------------------------------------------------------
596+// name: absyn_func_call2str()
597+// desc: convert abstract syntax func_call to string
598+//-----------------------------------------------------------------------------
599+string absyn_func_call2str( a_Exp_Func_Call func_call )
600+{
601+ string str;
602+ // function name
603+ str = absyn_exp2str( func_call->func );
604+ // args
605+ str += "(" + absyn_exp2str( func_call->args ) + ")";
606+ // done
607+ return str;
608+}
609+
610+
611+
612+
613+//-----------------------------------------------------------------------------
614+// name: absyn_dot_member2str()
615+// desc: convert abstract syntax dot_member to string
616+//-----------------------------------------------------------------------------
617+string absyn_dot_member2str( a_Exp_Dot_Member dot_member )
618+{
619+ return absyn_exp2str(dot_member->base) + "." + S_name(dot_member->xid);
620+}
621+
622+
623+
624+
625+//-----------------------------------------------------------------------------
626+// name: absyn_exp_if2str()
627+// desc: convert abstract syntax exp_if to string
628+//-----------------------------------------------------------------------------
629+string absyn_exp_if2str( a_Exp_If exp_if )
630+{
631+ return "("+absyn_exp2str(exp_if->cond) + "?" + absyn_exp2str(exp_if->if_exp)
632+ + ":" + absyn_exp2str(exp_if->else_exp)+")";
633+}
634+
635+
636+
637+
638+//-----------------------------------------------------------------------------
639+// name: absyn_decl2str()
640+// desc: convert abstract syntax decl to string
641+//-----------------------------------------------------------------------------
642+string absyn_decl2str( a_Exp_Decl decl )
643+{
644+ a_Var_Decl_List list = decl->var_decl_list;
645+ string str;
646+ a_Exp e = NULL;
647+
648+ if( decl->is_global ) str += "global ";
649+ else if( decl->is_static ) str += "static ";
650+
651+ while( list )
652+ {
653+ // type
654+ str += list->var_decl->value->type->name + " " + (decl->type->ref ? "@" : "") + list->var_decl->value->name;
655+ // array?
656+ if( list->var_decl->array )
657+ {
658+ e = list->var_decl->array->exp_list;
659+ if( e )
660+ {
661+ // loop over
662+ while( e )
663+ {
664+ // each index
665+ str += "[" + absyn_exp2str(e,false) + "]";
666+ // advance
667+ e = e->next;
668+ }
669+ }
670+ else
671+ {
672+ for( t_CKINT i = 0; i < list->var_decl->value->type->array_depth; i++ )
673+ {
674+ str += "[]";
675+ }
676+ }
677+ }
678+
679+ list = list->next;
680+ if( list ) str += ",";
681+ }
682+
683+ return str;
684+}

Keyboard shortcuts

General

Show keyboard shortcuts
?
Focus the current search
/

Issues and pull requests

Open filters
f

Issues, pull requests and Inbox

Select next item
j↓
Select previous item
k↑
Open selected item
Enter
Dismiss filters or clear selection
Esc

Repository code

Go to file
t