← Back to branch summary

~ubuntu-branches/ubuntu/lucid/graphviz/lucid-updates

« back to all changes in this revision

Viewing changes to cmd/gvpr/compile.c

  • Committer: Bazaar Package Importer
  • Author(s): Bryce Harrington
  • Date: 2008-06-19 20:23:23 UTC
  • mfrom: (1.2.5 upstream)
  • Revision ID: james.westby@ubuntu.com-20080619202323-ls23h96ntj9ny94m
Tags: 2.18-1ubuntu1
https://launchpad.net/bugs/174749
* Merge from debian unstable, remaining changes:
  - Build depend on liblualib50-dev instead of liblua5.1-0-dev.
  - Drop libttf-dev (libttf-dev is in universe) (LP: #174749).
  - Replace gs-common with ghostscript.
  - Build-depend on python-dev instead of python2.4-dev or python2.5-dev.
  - Mention the correct python version for the python bindings in the
    package description.

Show diffs side-by-side

added added

removed removed

Lines of Context:
cmd/gvpr/compile.c
1
 
/* $Id: compile.c,v 1.10 2007/07/17 21:46:06 erg Exp $ $Revision: 1.10 $ */
 
1
/* $Id: compile.c,v 1.11 2008/01/09 22:36:19 erg Exp $ $Revision: 1.11 $ */
2
2
/* vim:set shiftwidth=4 ts=8: */
3
3
 
4
4
/**********************************************************
34
34
#endif
35
35
#include <compile.h>
36
36
#include <assert.h>
 
37
#ifdef USE_CGRAPH
 
38
#include <cgraph.h>
 
39
#else
37
40
#include <agraph.h>
 
41
#endif
38
42
#include <error.h>
39
43
#include <actions.h>
40
44
#include <sfstr.h>
306
310
 * Apply symbol to get field value of objp
307
311
 * Assume objp != NULL
308
312
 */
309
 
static int lookup(Expr_t * pgm, Agobj_t * objp, Exid_t * sym, Extype_t * v)
 
313
static int lookup(Expr_t * pgm, Agobj_t * objp, Exid_t * sym, Extype_t * v,
 
314
  Gpr_t *state)
310
315
{
311
316
    if (sym->lex == ID) {
312
317
        switch (sym->index) {
331
336
            break;
332
337
        case M_indegree:
333
338
            if (AGTYPE(objp) == AGNODE)
 
339
#ifdef USE_CGRAPH
 
340
                v->integer = agdegree(state->curgraph, (Agnode_t *) objp, 1, 0);
 
341
#else
334
342
                v->integer = agdegree((Agnode_t *) objp, 1, 0);
 
343
#endif
335
344
            else {
336
345
                error(ERROR_FATAL, "indegree of non-node");
337
346
                return -1;
339
348
            break;
340
349
        case M_outdegree:
341
350
            if (AGTYPE(objp) == AGNODE)
 
351
#ifdef USE_CGRAPH
 
352
                v->integer = agdegree(state->curgraph, (Agnode_t *) objp, 0, 1);
 
353
#else
342
354
                v->integer = agdegree((Agnode_t *) objp, 0, 1);
 
355
#endif
343
356
            else {
344
357
                error(ERROR_FATAL, "outdegree of non-node");
345
358
                return -1;
347
360
            break;
348
361
        case M_degree:
349
362
            if (AGTYPE(objp) == AGNODE)
 
363
#ifdef USE_CGRAPH
 
364
                v->integer = agdegree(state->curgraph, (Agnode_t *) objp, 1, 1);
 
365
#else
350
366
                v->integer = agdegree((Agnode_t *) objp, 1, 1);
 
367
#endif
351
368
            else {
352
369
                error(ERROR_FATAL, "degree of non-node");
353
370
                return -1;
560
577
                error(ERROR_WARNING, "NULL node passed to addNode()");
561
578
                v.integer = 0;
562
579
            } else
563
 
                v.integer = PTR2INT(addNode(gp, np));
 
580
                v.integer = PTR2INT(addNode(gp, np, 1));
564
581
            break;
565
582
        case F_fstnode:
566
583
            gp = INT2PTR(Agraph_t *, args[0].integer);
575
592
        case F_nxtnode:
576
593
            np = INT2PTR(Agnode_t *, args[0].integer);
577
594
            if (np) {
 
595
#ifdef USE_CGRAPH
 
596
                np = agnxtnode(state->curgraph, np);
 
597
#else
578
598
                np = agnxtnode(np);
 
599
#endif
579
600
                v.integer = PTR2INT(np);
580
601
            } else {
581
602
                error(ERROR_WARNING, "NULL node passed to nxtnode()");
582
603
                v.integer = 0;
583
604
            }
584
605
            break;
 
606
        case F_nxtnodesg:
 
607
#ifdef USE_CGRAPH
 
608
            gp = INT2PTR(Agraph_t *, args[0].integer);
 
609
            np = INT2PTR(Agnode_t *, args[1].integer);
 
610
            if (!gp)
 
611
                gp = state->curgraph;
 
612
            if (np) {
 
613
                np = agnxtnode(gp, np);
 
614
                v.integer = PTR2INT(np);
 
615
            } else {
 
616
                error(ERROR_WARNING, "NULL node passed to nxtnode_sg()");
 
617
                v.integer = 0;
 
618
            }
 
619
#else
 
620
                error(ERROR_FATAL, "nxtnode_sg currently unsupported");
 
621
#endif
 
622
            break;
585
623
        case F_isnode:
586
624
            gp = INT2PTR(Agraph_t *, args[0].integer);
587
625
            if (gp) {
591
629
                v.integer = 0;
592
630
            }
593
631
            break;
 
632
        case F_issubnode:
 
633
#ifdef USE_CGRAPH
 
634
            gp = INT2PTR(Agraph_t *, args[0].integer);
 
635
            np = INT2PTR(Agnode_t *, args[1].integer);
 
636
            if (!gp)
 
637
                gp = state->curgraph;
 
638
            if (np) {
 
639
                v.integer = PTR2INT(addNode(gp, np, 0));
 
640
            } else {
 
641
                error(ERROR_WARNING, "NULL node passed to isSubnode()");
 
642
                v.integer = 0;
 
643
            }
 
644
#else
 
645
                error(ERROR_FATAL, "isSubnode currently unsupported");
 
646
#endif
 
647
            break;
 
648
        case F_indegree:
 
649
#ifdef USE_CGRAPH
 
650
            gp = INT2PTR(Agraph_t *, args[0].integer);
 
651
            np = INT2PTR(Agnode_t *, args[1].integer);
 
652
            if (!gp)
 
653
                gp = state->curgraph;
 
654
            if (np) {
 
655
                v.integer = agdegree(gp, np, 1, 0);
 
656
            } else {
 
657
                error(ERROR_WARNING, "NULL node passed to indegreeOf()");
 
658
                v.integer = 0;
 
659
            }
 
660
#else
 
661
                error(ERROR_FATAL, "indegreeOf currently unsupported");
 
662
#endif
 
663
            break;
 
664
        case F_outdegree:
 
665
#ifdef USE_CGRAPH
 
666
            gp = INT2PTR(Agraph_t *, args[0].integer);
 
667
            np = INT2PTR(Agnode_t *, args[1].integer);
 
668
            if (!gp)
 
669
                gp = state->curgraph;
 
670
            if (np) {
 
671
                v.integer = agdegree(gp, np, 0, 1);
 
672
            } else {
 
673
                error(ERROR_WARNING, "NULL node passed to outdegreeOf()");
 
674
                v.integer = 0;
 
675
            }
 
676
#else
 
677
                error(ERROR_FATAL, "outdegreeOf currently unsupported");
 
678
#endif
 
679
            break;
 
680
        case F_degree:
 
681
#ifdef USE_CGRAPH
 
682
            gp = INT2PTR(Agraph_t *, args[0].integer);
 
683
            np = INT2PTR(Agnode_t *, args[1].integer);
 
684
            if (!gp)
 
685
                gp = state->curgraph;
 
686
            if (np) {
 
687
                v.integer = agdegree(gp, np, 1, 1);
 
688
            } else {
 
689
                error(ERROR_WARNING, "NULL node passed to degreeOf()");
 
690
                v.integer = 0;
 
691
            }
 
692
#else
 
693
                error(ERROR_FATAL, "degreeOf currently unsupported");
 
694
#endif
 
695
            break;
594
696
        case F_isin:
595
697
            gp = INT2PTR(Agraph_t *, args[0].integer);
596
698
            objp = INT2PTR(Agobj_t *, args[1].integer);
646
748
                error(ERROR_WARNING, "NULL head node passed to edge()");
647
749
                v.integer = 0;
648
750
            } else {
649
 
                ep = openEdge(np, hp, key);
650
 
                v.integer = PTR2INT(ep);
651
 
            }
 
751
                ep = openEdge(0, np, hp, key);
 
752
                v.integer = PTR2INT(ep);
 
753
            }
 
754
            break;
 
755
        case F_edgesg:
 
756
#ifdef USE_CGRAPH
 
757
            key = args[3].string;
 
758
            if (*key == '\0')
 
759
                key = 0;
 
760
            gp = INT2PTR(Agraph_t *, args[0].integer);
 
761
            np = INT2PTR(Agnode_t *, args[1].integer);
 
762
            hp = INT2PTR(Agnode_t *, args[2].integer);
 
763
            if (!np) {
 
764
                error(ERROR_WARNING, "NULL tail node passed to edge_sg()");
 
765
                v.integer = 0;
 
766
            } else if (!hp) {
 
767
                error(ERROR_WARNING, "NULL head node passed to edge_sg()");
 
768
                v.integer = 0;
 
769
            } else {
 
770
                ep = openEdge(gp, np, hp, key);
 
771
                v.integer = PTR2INT(ep);
 
772
            }
 
773
#else
 
774
                error(ERROR_FATAL, "edge_sg currently unsupported");
 
775
#endif
652
776
            break;
653
777
        case F_addedge:
654
778
            gp = INT2PTR(Agraph_t *, args[0].integer);
660
784
                error(ERROR_WARNING, "NULL edge passed to addEdge()");
661
785
                v.integer = 0;
662
786
            } else
663
 
                v.integer = PTR2INT(addEdge(gp, ep));
 
787
                v.integer = PTR2INT(addEdge(gp, ep, 1));
664
788
            break;
665
789
        case F_isedge:
666
790
            key = args[2].string;
675
799
                error(ERROR_WARNING, "NULL head node passed to isEdge()");
676
800
                v.integer = 0;
677
801
            } else
678
 
                v.integer = PTR2INT(isEdge(np, hp, key));
 
802
                v.integer = PTR2INT(isEdge(state->curgraph, np, hp, key));
 
803
            break;
 
804
        case F_isedgesg:
 
805
#ifdef USE_CGRAPH
 
806
            key = args[3].string;
 
807
            if (*key == '\0')
 
808
                key = 0;
 
809
            gp = INT2PTR(Agraph_t *, args[0].integer);
 
810
            np = INT2PTR(Agnode_t *, args[1].integer);
 
811
            hp = INT2PTR(Agnode_t *, args[2].integer);
 
812
            if (!gp)
 
813
                gp = state->curgraph;
 
814
            if (!np) {
 
815
                error(ERROR_WARNING, "NULL tail node passed to isEdge_sg()");
 
816
                v.integer = 0;
 
817
            } else if (!hp) {
 
818
                error(ERROR_WARNING, "NULL head node passed to isEdge_sg()");
 
819
                v.integer = 0;
 
820
            } else
 
821
                v.integer = PTR2INT(isEdge(gp, np, hp, key));
 
822
#else
 
823
                error(ERROR_FATAL, "isEdge_sg currently unsupported");
 
824
#endif
 
825
            break;
 
826
        case F_issubedge:
 
827
#ifdef USE_CGRAPH
 
828
            gp = INT2PTR(Agraph_t *, args[0].integer);
 
829
            ep = INT2PTR(Agedge_t *, args[1].integer);
 
830
            if (!gp)
 
831
                gp = state->curgraph;
 
832
            if (ep) {
 
833
                v.integer = PTR2INT(addEdge(gp, ep, 0));
 
834
            } else {
 
835
                error(ERROR_WARNING, "NULL edge passed to isSubedge()");
 
836
                v.integer = 0;
 
837
            }
 
838
#else
 
839
                error(ERROR_FATAL, "isSubedge currently unsupported");
 
840
#endif
679
841
            break;
680
842
        case F_fstout:
681
843
            np = INT2PTR(Agnode_t *, args[0].integer);
682
844
            if (np) {
 
845
#ifdef USE_CGRAPH
 
846
                ep = agfstout(state->curgraph, np);
 
847
#else
683
848
                ep = agfstout(np);
 
849
#endif
684
850
                v.integer = PTR2INT(ep);
685
851
            } else {
686
852
                error(ERROR_WARNING, "NULL node passed to fstout()");
687
853
                v.integer = 0;
688
854
            }
689
855
            break;
 
856
        case F_fstoutsg:
 
857
#ifdef USE_CGRAPH
 
858
            gp = INT2PTR(Agraph_t *, args[0].integer);
 
859
            np = INT2PTR(Agnode_t *, args[1].integer);
 
860
            if (!gp)
 
861
                gp = state->curgraph;
 
862
            if (np) {
 
863
                ep = agfstout(gp, np);
 
864
                v.integer = PTR2INT(ep);
 
865
            } else {
 
866
                error(ERROR_WARNING, "NULL node passed to fstout_sg()");
 
867
                v.integer = 0;
 
868
            }
 
869
#else
 
870
                error(ERROR_FATAL, "fstout_sg currently unsupported");
 
871
#endif
 
872
            break;
690
873
        case F_nxtout:
691
874
            ep = INT2PTR(Agedge_t *, args[0].integer);
692
875
            if (ep) {
 
876
#ifdef USE_CGRAPH
 
877
                ep = agnxtout(state->curgraph, ep);
 
878
#else
693
879
                ep = agnxtout(ep);
 
880
#endif
694
881
                v.integer = PTR2INT(ep);
695
882
            } else {
696
883
                error(ERROR_WARNING, "NULL edge passed to nxtout()");
697
884
                v.integer = 0;
698
885
            }
699
886
            break;
 
887
        case F_nxtoutsg:
 
888
#ifdef USE_CGRAPH
 
889
            gp = INT2PTR(Agraph_t *, args[0].integer);
 
890
            ep = INT2PTR(Agedge_t *, args[1].integer);
 
891
            if (!gp)
 
892
                gp = state->curgraph;
 
893
            if (ep) {
 
894
                ep = agnxtout(gp, ep);
 
895
                v.integer = PTR2INT(ep);
 
896
            } else {
 
897
                error(ERROR_WARNING, "NULL edge passed to nxtout_sg()");
 
898
                v.integer = 0;
 
899
            }
 
900
#else
 
901
                error(ERROR_FATAL, "nxtout_sg currently unsupported");
 
902
#endif
 
903
            break;
700
904
        case F_fstin:
701
905
            np = INT2PTR(Agnode_t *, args[0].integer);
702
906
            if (np) {
 
907
#ifdef USE_CGRAPH
 
908
                ep = agfstin(state->curgraph, np);
 
909
#else
703
910
                ep = agfstin(np);
 
911
#endif
704
912
                v.integer = PTR2INT(ep);
705
913
            } else {
706
914
                error(ERROR_WARNING, "NULL node passed to fstin()");
707
915
                v.integer = 0;
708
916
            }
709
917
            break;
 
918
        case F_fstinsg:
 
919
#ifdef USE_CGRAPH
 
920
            gp = INT2PTR(Agraph_t *, args[0].integer);
 
921
            np = INT2PTR(Agnode_t *, args[1].integer);
 
922
            if (!gp)
 
923
                gp = state->curgraph;
 
924
            if (np) {
 
925
                ep = agfstin(gp, np);
 
926
                v.integer = PTR2INT(ep);
 
927
            } else {
 
928
                error(ERROR_WARNING, "NULL node passed to fstin_sg()");
 
929
                v.integer = 0;
 
930
            }
 
931
#else
 
932
                error(ERROR_FATAL, "fstin_sg currently unsupported");
 
933
#endif
 
934
            break;
710
935
        case F_nxtin:
711
936
            ep = INT2PTR(Agedge_t *, args[0].integer);
712
937
            if (ep) {
 
938
#ifdef USE_CGRAPH
 
939
                ep = agnxtin(state->curgraph, ep);
 
940
#else
713
941
                ep = agnxtin(ep);
 
942
#endif
714
943
                v.integer = PTR2INT(ep);
715
944
            } else {
716
945
                error(ERROR_WARNING, "NULL edge passed to nxtin()");
717
946
                v.integer = 0;
718
947
            }
719
948
            break;
 
949
        case F_nxtinsg:
 
950
#ifdef USE_CGRAPH
 
951
            gp = INT2PTR(Agraph_t *, args[0].integer);
 
952
            ep = INT2PTR(Agedge_t *, args[1].integer);
 
953
            if (!gp)
 
954
                gp = state->curgraph;
 
955
            if (ep) {
 
956
                ep = agnxtin(gp, ep);
 
957
                v.integer = PTR2INT(ep);
 
958
            } else {
 
959
                error(ERROR_WARNING, "NULL edge passed to nxtin_sg()");
 
960
                v.integer = 0;
 
961
            }
 
962
#else
 
963
                error(ERROR_FATAL, "nxtin_sg currently unsupported");
 
964
#endif
 
965
            break;
720
966
        case F_fstedge:
721
967
            np = INT2PTR(Agnode_t *, args[0].integer);
722
968
            if (np) {
 
969
#ifdef USE_CGRAPH
 
970
                ep = agfstedge(state->curgraph, np);
 
971
#else
723
972
                ep = agfstedge(np);
 
973
#endif
724
974
                v.integer = PTR2INT(ep);
725
975
            } else {
726
976
                error(ERROR_WARNING, "NULL node passed to fstedge()");
727
977
                v.integer = 0;
728
978
            }
729
979
            break;
 
980
        case F_fstedgesg:
 
981
#ifdef USE_CGRAPH
 
982
            gp = INT2PTR(Agraph_t *, args[0].integer);
 
983
            np = INT2PTR(Agnode_t *, args[1].integer);
 
984
            if (!gp)
 
985
                gp = state->curgraph;
 
986
            if (np) {
 
987
                ep = agfstedge(gp, np);
 
988
                v.integer = PTR2INT(ep);
 
989
            } else {
 
990
                error(ERROR_WARNING, "NULL node passed to fstedge_sg()");
 
991
                v.integer = 0;
 
992
            }
 
993
#else
 
994
                error(ERROR_FATAL, "fstedge_sg currently unsupported");
 
995
#endif
 
996
            break;
730
997
        case F_nxtedge:
731
998
            ep = INT2PTR(Agedge_t *, args[0].integer);
732
999
            np = INT2PTR(Agnode_t *, args[1].integer);
737
1004
                error(ERROR_WARNING, "NULL node passed to nxtedge()");
738
1005
                v.integer = 0;
739
1006
            } else {
 
1007
#ifdef USE_CGRAPH
 
1008
                ep = agnxtedge(state->curgraph, ep, np);
 
1009
#else
740
1010
                ep = agnxtedge(ep, np);
741
 
                v.integer = PTR2INT(ep);
742
 
            }
 
1011
#endif
 
1012
                v.integer = PTR2INT(ep);
 
1013
            }
 
1014
            break;
 
1015
        case F_nxtedgesg:
 
1016
#ifdef USE_CGRAPH
 
1017
            gp = INT2PTR(Agraph_t *, args[0].integer);
 
1018
            ep = INT2PTR(Agedge_t *, args[1].integer);
 
1019
            np = INT2PTR(Agnode_t *, args[2].integer);
 
1020
            if (!gp)
 
1021
                gp = state->curgraph;
 
1022
            if (!ep) {
 
1023
                error(ERROR_WARNING, "NULL edge passed to nxtedge_sg()");
 
1024
                v.integer = 0;
 
1025
            } else if (!np) {
 
1026
                error(ERROR_WARNING, "NULL node passed to nxtedge_sg()");
 
1027
                v.integer = 0;
 
1028
            } else {
 
1029
                ep = agnxtedge(gp, ep, np);
 
1030
                v.integer = PTR2INT(ep);
 
1031
            }
 
1032
#else
 
1033
                error(ERROR_FATAL, "nxtedge_sg currently unsupported");
 
1034
#endif
743
1035
            break;
744
1036
        case F_copy:
745
1037
            gp = INT2PTR(Agraph_t *, args[0].integer);
1067
1359
                  deparse(pgm, node, state->tmp));
1068
1360
    }
1069
1361
 
1070
 
    if (lookup(pgm, objp, sym, &v))
 
1362
    if (lookup(pgm, objp, sym, &v, state))
1071
1363
        error(ERROR_FATAL, "in expression %s",
1072
1364
              deparse(pgm, node, state->tmp));
1073
1365
 
1991
2283
 * Create edge and initialize dynamic data.
1992
2284
 * The edge is always created in the root graph.
1993
2285
 */
1994
 
Agedge_t *openEdge(Agnode_t * t, Agnode_t * h, char *key)
 
2286
Agedge_t *openEdge(Agraph_t* g, Agnode_t * t, Agnode_t * h, char *key)
1995
2287
{
1996
2288
    Agedge_t *ep;
1997
2289
    Agraph_t *root;
1999
2291
    root = sameG(t, h, "openEdge", "tail and head node");
2000
2292
    if (!root)
2001
2293
        return 0;
 
2294
#ifdef USE_CGRAPH
 
2295
    if (g && (root != agroot(g)))
 
2296
        return 0;
 
2297
    else
 
2298
        g = root;
2002
2299
 
 
2300
    ep = agedge(g, t, h, key, 1);
 
2301
#else
2003
2302
    t = (Agnode_t *) agrebind(root, OBJ(t));
2004
2303
    h = (Agnode_t *) agrebind(root, OBJ(h));
2005
2304
    ep = agedge(t, h, key, 1);
 
2305
#endif
2006
2306
    if (ep && !aggetrec(ep, UDATA, 0))
2007
2307
        agbindrec(ep, UDATA, sizeof(edata), 0);
2008
2308
    return ep;