Mercurial > repos > rhope

comparison nworker.rhope @ 36:495dddadd058

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
User defined types work in the compiler now
author Mike Pavone <pavone@retrodev.com>
date Sat, 03 Oct 2009 03:18:15 -0400
parents df038cef648b
children 640f541e9116
comparison
equal deleted inserted replaced
35:3498713c3dc9 36:495dddadd058
295 { 295 {
296 ,node index <- [worker]Add Node["output",number,1,0] 296 ,node index <- [worker]Add Node["output",number,1,0]
297 { out <- [~]Outputs <<[[[~]Outputs >>]Set[number,name]] } 297 { out <- [~]Outputs <<[[[~]Outputs >>]Set[number,name]] }
298 } 298 }
299 299
300 Add Object Get@NWorker[worker,fieldname:out,node index]
301 {
302 out, node index <- [worker]Add Node["getfield",fieldname,1,1]
303 }
304
305 Add Object Set@NWorker[worker,fieldname:out,node index]
306 {
307 out, node index <- [worker]Add Node["setfield",fieldname,2,1]
308 }
309
300 Add Wire@NWorker[worker,from,output,to,input:out] 310 Add Wire@NWorker[worker,from,output,to,input:out]
301 { 311 {
302 Print[[[[[[[[["Add Wire@NWorker["]Append[from]]Append[","]]Append[output]]Append[","]]Append[to]]Append[","]]Append[input]]Append["]"]] 312 Print[[[[[[[[["Add Wire@NWorker["]Append[from]]Append[","]]Append[output]]Append[","]]Append[to]]Append[","]]Append[input]]Append["]"]]
303 { 313 {
304 fromw <- [[[worker]Nodes >>]Index[from]]Wire From[to,input,output] 314 fromw <- [[[worker]Nodes >>]Index[from]]Wire From[to,input,output]
418 } 428 }
419 429
420 Format Input@NWorker[worker,noderef:out] 430 Format Input@NWorker[worker,noderef:out]
421 { 431 {
422 node <- [[worker]Nodes >>]Index[[noderef]Index >>] 432 node <- [[worker]Nodes >>]Index[[noderef]Index >>]
423 If[[[node]Type >>] = ["call"]] 433 [("call","getfield","setfield")]Find[[node]Type >>]
424 { 434 {
425 out <- AddRef[ [[["__result_"]Append[[noderef]Index >>]]Append["_"]]Append[[noderef]IO Num >>] ] 435 out <- AddRef[ [[["__result_"]Append[[noderef]Index >>]]Append["_"]]Append[[noderef]IO Num >>] ]
426 }{ 436 }{
427 If[[[node]Type >>] = ["input"]] 437 If[[[node]Type >>] = ["input"]]
428 { 438 {
429 input name <- [[worker]Inputs >>]Index[ [node]Data >> ] 439 input name <- [[worker]Inputs >>]Index[ [node]Data >> ]
430 out <- AddRef[input name] 440 out <- AddRef[input name]
431 }{ 441 }{
432 If[[[node]Type >>] = ["const"]] 442 If[[[node]Type >>] = ["const"]]
433 { 443 {
434 out <- Constant[[[Type Of[[node]Data >>]]Append["_"]]Append[[node]Data >>]] 444 If[[Type Of[[node]Data >>]] = ["Type Literal"]]
445 {
446 //TODO: Support parametric types
447 datstring <- [[node]Data >>]Name >>
448 }{
449 datstring <- [node]Data >>
450 }
451 out <- Constant[[[Type Of[[node]Data >>]]Append["_"]]Append[datstring]]
452
435 } 453 }
436 } 454 }
437 } 455 }
438 } 456 }
439 457
496 out <- [func]Move[Result[num], out var] 514 out <- [func]Move[Result[num], out var]
497 } 515 }
498 516
499 Compile Call Node[node,program,func,inputs,node index:out] 517 Compile Call Node[node,program,func,inputs,node index:out]
500 { 518 {
501 [program]Method?[[[node]Data >>]Name >>] 519 If[[[node]Type >>] = ["getfield"]]
502 { 520 {
503 Print["Method!"] 521 with call <- [func]Get Field Call[[node]Data >>, [inputs]Index[0]]
504 with call <- [func]Method Call[[[node]Data >>]Name >>, inputs] 522 }{
505 { Print["Method Call done"] } 523 If[[[node]Type >>] = ["setfield"]]
506 }{ 524 {
507 Print["Function!"] 525 with call <- [func]Set Field Call[[node]Data >>, [inputs]Index[0], [inputs]Index[1]]
508 with call <- [func]Call[[[node]Data >>]Name >>, inputs] 526 }{
527 Print[["Call: "]Append[[[node]Data >>]Name >>]]
528 {
529 [program]Method?[[[node]Data >>]Name >>]
530 {
531 Print["Method!"]
532 with call <- [func]Method Call[[[node]Data >>]Name >>, inputs]
533 { Print["Method Call done"] }
534 }{
535 Print["Function!"]
536 with call <- [func]Call[[[node]Data >>]Name >>, inputs]
537 }
538 }
539 }
509 } 540 }
510 out <- Fold[["Save Result"]Set Input[2, node index], with call, Range[0, [node]Outputs >>]] 541 out <- Fold[["Save Result"]Set Input[2, node index], with call, Range[0, [node]Outputs >>]]
511 } 542 }
512 543
513 Compile Node@NWorker[worker,program,func,nodes,current:out,out worker] 544 Compile Node@NWorker[worker,program,func,nodes,current:out,out worker]
514 { 545 {
515 Print[["Compile Node: "]Append[[node]Type >>]] 546 Print[["Compile Node: "]Append[[node]Type >>]]
516 node index <- [nodes]Index[current] 547 node index <- [nodes]Index[current]
517 node <- [[worker]Nodes >>]Index[node index] 548 node <- [[worker]Nodes >>]Index[node index]
518 conditions <- [worker]Collect Conditions[node] 549 conditions <- [worker]Collect Conditions[node]
519 If[[[node]Type >>] = ["call"]] 550 [("call","getfield","setfield")]Find[[node]Type >>]
520 { 551 {
521 Print[["Call: "]Append[[[node]Data >>]Name >>]]
522
523 inputs <- [worker]Collect Inputs[node] 552 inputs <- [worker]Collect Inputs[node]
524 [conditions]For Backend 553 [conditions]For Backend
525 { 554 {
526 Print["Conditional execution, do if"] 555 Print["Conditional execution, do if"]
527 stream <- [func]Instruction Stream 556 stream <- [func]Instruction Stream
547 nstream <- [stream]Move[[inputs]Index[0], [[worker]Outputs >>]Index[ [node]Data >> ] ] 576 nstream <- [stream]Move[[inputs]Index[0], [[worker]Outputs >>]Index[ [node]Data >> ] ]
548 }{ 577 }{
549 If[[[node]Type >>] = ["const"]] 578 If[[[node]Type >>] = ["const"]]
550 { 579 {
551 //TODO: Handle list constants 580 //TODO: Handle list constants
552 nfunc <- [func]Register Constant[[[Type Of[[node]Data >>]]Append["_"]]Append[[node]Data >>], [node]Data >>] 581 If[[Type Of[[node]Data >>]] = ["Type Literal"]]
582 {
583 //TODO: Support parametric types
584 datstring <- [[node]Data >>]Name >>
585 }{
586 datstring <- [node]Data >>
587 }
588 nfunc <- [func]Register Constant[[[Type Of[[node]Data >>]]Append["_"]]Append[datstring], [node]Data >>]
553 }{ 589 }{
554 nfunc <- Val[func] 590 nfunc <- Val[func]
555 } 591 }
556 592
557 } 593 }
617 out <- [vars]Append[[[["__result_"]Append[index]]Append["_"]]Append[io num]] 653 out <- [vars]Append[[[["__result_"]Append[index]]Append["_"]]Append[io num]]
618 } 654 }
619 655
620 Node Result Vars[vars,node,index:out] 656 Node Result Vars[vars,node,index:out]
621 { 657 {
622 If[[[node]Type >>] = ["call"]] 658 [("call","getfield","setfield")]Find[[node]Type >>]
623 { 659 {
624 out <- Fold[["Result Var"]Set Input[2, index], vars, Range[0, [node]Outputs >>]] 660 out <- Fold[["Result Var"]Set Input[2, index], vars, Range[0, [node]Outputs >>]]
625 }{ 661 }{
626 out <- vars 662 out <- vars
627 } 663 }
674 Test Graph to Backend[:out] 710 Test Graph to Backend[:out]
675 { 711 {
676 out <- [Test[]]Compile Worker[C Program[], "Test"] 712 out <- [Test[]]Compile Worker[C Program[], "Test"]
677 } 713 }
678 714
715 Blueprint NBlueprint
716 {
717 Fields
718 Methods
719 }
720
721 NBlueprint[:out]
722 {
723 out <- [[Build["NBlueprint"]]Fields <<[()]]Methods <<[New@Dictionary[]]
724 }
725
726 Add Field@NBlueprint[bp,name,type:out]
727 {
728 out <- [bp]Fields <<[ [[bp]Fields >>]Append[ [[()]Append[name]]Append[type] ] ]
729 }
730
731 Add Method@NBlueprint[bp,name:out]
732 {
733 out <- [bp]Methods <<[ [[bp]Methods >>]Set[name, Yes] ]
734 }
735
736 _Compile Blueprint Fields[type,field:out]
737 {
738 name <- [field]Index[0]
739 ftype <- [field]Index[1]
740 out <- [type]Add Field[name,ftype]
741 }
742
743 _Compile Blueprint Methods[type,junk,name:out]
744 {
745 out <- [type]Add Method[name]
746 }
747
748 Make Init[func,field:out]
749 {
750 name <- [field]Index[0]
751 out <- [func]Set Field Null["obj", name]
752 }
753
754 Make Copy[func,field:out]
755 {
756 name <- [field]Index[0]
757 got <- [func]Read Field["obj", name] {}
758 {
759 stream <- [[got]Instruction Stream
760 ]AddRef No Dest[~]
761 out <- [got]Do If[~, stream]
762 }
763 }
764
765 Make Cleanup[func,field:out]
766 {
767 name <- [field]Index[0]
768 got <- [func]Read Field["obj", name] {}
769 {
770 stream <- [[got]Instruction Stream
771 ]Release[~]
772 out <- [got]Do If[~, stream]
773 }
774 }
775
776 Make Special@NBlueprint[bp,backend,func name,bp name,pop worker:out]
777 {
778 func <- [[backend]Create Function[func name,("obj"),(),"cdecl"]
779 ]Set Input Type[0, bp name]
780 out <- [backend]Store Function[Fold[pop worker, func, [bp]Fields >>]]
781 }
782
783 Getters Setters[backend,field,type name:out]
784 {
785 //TODO: Throw an exception or something if we read a field that is empty
786 Print[["Getters Setters: "]Append[name]]
787 name <- [field]Index[0]
788 type <- [field]Index[1]
789 ,getref <- [[[[backend]Create Function[ [[[name]Append[" >>"]]Append["@"]]Append[type name], ("obj"), ("out"), "rhope"]
790 ]Set Input Type[0, type name]
791 ]Set Output Type[0, type]
792 ]Read Field["obj", name]
793 { getter <- [~]Do AddRef[getref, "out"]
794 { Print["Got getter"] } }
795
796 ,origref <- [[[[[[backend]Create Function[ [[[name]Append[" <<"]]Append["@"]]Append[type name], ("obj","newval"), ("out"), "rhope"]
797 ]Set Input Type[0, type name]
798 ]Set Input Type[1, type]
799 ]Set Output Type[0, type name]
800 ]Copy["obj"]
801 ]Read Field["obj", name]
802 {
803 stream <- [[~]Instruction Stream
804 ]Release[origref]
805 ,setref <- [[~]Do If[origref, stream]
806 ]Write Field["obj", name]
807 {
808 setter <- [[~]Move["newval", setref]
809 ]Move["obj", "out"]
810 { Print["got setter"] }
811 }
812 }
813
814 out <- [[backend]Store Function[getter]]Store Function[setter]
815
816 }
817
818 Compile Blueprint@NBlueprint[bp,backend,name:out]
819 {
820
821 //Rhope identifiers can't start with spaces, so we can use identifiers that start with spaces for special functions
822 init name <- [" init "]Append[name]
823 copy name <- [" copy "]Append[name]
824 cleanup name <- [" cleanup "]Append[name]
825 type <- [[[Fold["_Compile Blueprint Methods", Fold["_Compile Blueprint Fields", [backend]Create Type[name], [bp]Fields >>], [bp]Methods >>]
826 ]Init <<[init name]
827 ]Copy <<[copy name]
828 ]Cleanup <<[cleanup name]
829
830 got specials <- [bp]Make Special[
831 [bp]Make Special[
832 [bp]Make Special[[backend]Register Type[type], init name, name, "Make Init"],
833 copy name, name, "Make Copy"],
834 cleanup name, name, "Make Cleanup"]
835 out <- Fold[["Getters Setters"]Set Input[2, name], got specials, [bp]Fields >>]
836 }
837
679 Blueprint NProgram 838 Blueprint NProgram
680 { 839 {
681 Blueprints 840 Blueprints
682 Workers 841 Workers
683 Worker Refs 842 Worker Refs
687 { 846 {
688 out <- [[[Build["NProgram"]]Blueprints <<[New@Dictionary[]]]Workers <<[New@Dictionary[]]]Worker Refs <<[New@Dictionary[]] 847 out <- [[[Build["NProgram"]]Blueprints <<[New@Dictionary[]]]Workers <<[New@Dictionary[]]]Worker Refs <<[New@Dictionary[]]
689 } 848 }
690 849
691 Bind Worker@NProgram[prog,name,worker:out] 850 Bind Worker@NProgram[prog,name,worker:out]
692 { 851 {
693 out <- [prog]Workers << [ [[prog]Workers >>]Set[name, worker] ] 852 after bind <- [prog]Workers << [ [[prog]Workers >>]Set[name, worker] ]
853 parts <- [name]Split["@"]
854 [parts]Index[1]
855 {
856 out <- [after bind]Blueprints <<[ [[after bind]Blueprints >>]Set[~, [[[after bind]Blueprints >>]Index[~]]Add Method[[parts]Index[0]] ] ]
857 }{
858 out <- Val[after bind]
859 }
694 } 860 }
695 861
696 Bind Blueprint@NProgram[prog,name,blueprint:out] 862 Bind Blueprint@NProgram[prog,name,blueprint:out]
697 { 863 {
864 Print[["Bind blueprint: "]Append[name]]
698 out <- [prog]Blueprints << [ [[prog]Blueprints >>]Set[name, blueprint] ] 865 out <- [prog]Blueprints << [ [[prog]Blueprints >>]Set[name, blueprint] ]
699 } 866 }
700 867
868 _Compile Program BP[backend, blueprint, name:out]
869 {
870 out <- [blueprint]Compile Blueprint[backend, name]
871 }
872
701 _Compile Program[backend, worker, name:out] 873 _Compile Program[backend, worker, name:out]
702 { 874 {
703 out <- [worker]Compile Worker[backend, name] 875 out <- [worker]Compile Worker[backend, name]
704 } 876 }
705 877
706 Compile Program@NProgram[prog, backend:out] 878 Compile Program@NProgram[prog, backend:out]
707 { 879 {
708 out <- Fold["_Compile Program", backend, [prog]Workers >>] 880 out <- Fold["_Compile Program", Fold["_Compile Program BP", backend, [prog]Blueprints >>], [prog]Workers >>]
709 } 881 }
710 882
711 Register Worker@NProgram[prog, name, convention, inputs, outputs: out] 883 Register Worker@NProgram[prog, name, convention, inputs, outputs: out]
712 { 884 {
713 Print[["Register Worker "]Append[name]] 885 Print[["Register Worker "]Append[name]]
714 out <- [prog]Worker Refs <<[ [[prog]Worker Refs >>]Set[name, Worker Ref[name, convention, inputs, outputs]]] 886 after reg <- [prog]Worker Refs <<[ [[prog]Worker Refs >>]Set[name, Worker Ref[name, convention, inputs, outputs]]]
887 parts <- [name]Split["@"]
888 [parts]Index[1]
889 {
890 out <- [prog]Register Worker[[parts]Index[0], convention, inputs, outputs]
891 }{
892 out <- Val[after reg]
893 }
715 } 894 }
716 895
717 Register Builtins@NProgram[prog:out] 896 Register Builtins@NProgram[prog:out]
718 { 897 {
719 out <- [[[[[[[[[prog]Register Worker["+", "rhope", 2, 1] 898 out <- [[[[[[[[[prog]Register Worker["+@Int32", "rhope", 2, 1]
720 ]Register Worker["-", "rhope", 2, 1] 899 ]Register Worker["-@Int32", "rhope", 2, 1]
721 ]Register Worker["*", "rhope", 2, 1] 900 ]Register Worker["*@Int32", "rhope", 2, 1]
722 ]Register Worker["/", "rhope", 2, 1] 901 ]Register Worker["/@Int32", "rhope", 2, 1]
723 ]Register Worker["Print", "rhope", 1, 1] 902 ]Register Worker["Print", "rhope", 1, 1]
724 ]Register Worker["Index", "rhope", 2, 1] 903 ]Register Worker["If@Yes No", "rhope", 1, 2]
725 ]Register Worker["If", "rhope", 1, 2] 904 ]Register Worker["<@Int32", "rhope", 2, 1]
726 ]Register Worker["<", "rhope", 2, 1] 905 ]Register Worker[">@Int32", "rhope", 1, 1]
727 ]Register Worker[">", "rhope", 1, 1] 906 ]Register Worker["Build", "rhope", 1, 1]
728 } 907 }
729 908
730 Find Worker@NProgram[prog, name:out,notfound] 909 Find Worker@NProgram[prog, name:out,notfound]
731 { 910 {
732 Print[ ["Find Worker@NProgram: "]Append[name] ] 911 Print[ ["Find Worker@NProgram: "]Append[name] ]
733 out,notfound <- [[prog]Worker Refs >>]Index[name] 912 out,notfound <- [[prog]Worker Refs >>]Index[name]
734 } 913 }
914