home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_progs / prog_c / tpledit.lzh / TPLEDIT / SRC / LOAD.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-08-15  |  5.4 KB  |  284 lines
  1.  
  2. /*
  3.  *  LOAD.C
  4.  */
  5.  
  6. #include "defs.h"
  7.  
  8. Prototype void LoadProject(char *);
  9. Prototype void ScanProject(short, FILE *, long);
  10. Prototype void ResolveLinks(void);
  11. Prototype void UnResolveIDs(void);
  12. Prototype void ResolveIDs(void);
  13.  
  14. void
  15. LoadProject(name)
  16. char *name;
  17. {
  18.     FILE *fi;
  19.  
  20.     UnResolveIDs();
  21.     if ((fi = fopen(name, "r")) == NULL) {
  22.     printf("unable to open %s\n", name);
  23.     return;
  24.     }
  25.     ScanProject(0, fi, -1);
  26.     fclose(fi);
  27.     ResolveIDs();
  28. }
  29.  
  30. void
  31. ScanProject(state, fi, endOffset)
  32. short state;
  33. FILE *fi;
  34. long endOffset;
  35. {
  36.     ProjEntry pe;
  37.     long subEndOffset;
  38.  
  39.     while (ftell(fi) != endOffset) {
  40.     if (fread(&pe, sizeof(pe), 1, fi) != 1)
  41.         return;
  42.  
  43.     subEndOffset = ftell(fi) + pe.pe_Len;
  44.  
  45.     if (DDebug)
  46.         printf("TYPE %d ENDS %08lx\n", pe.pe_Type, subEndOffset);
  47.  
  48.     switch(pe.pe_Type) {
  49.     case PT_PROJECT:
  50.         ScanProject(pe.pe_Type, fi, subEndOffset);
  51.         ResolveLinks();
  52.         break;
  53.     case PT_HEADER:
  54.         fread(&Ph, pe.pe_Len, 1, fi);
  55.         break;
  56.     case PT_REGION:
  57.         if (CurRegion) {
  58.         puts("ScanError: region in region!");
  59.         break;
  60.         }
  61.         CurRegion = AllocTplRegion();
  62.         ScanProject(pe.pe_Type, fi, subEndOffset);
  63.  
  64.         /*
  65.          *    Handle list copy if RGT_CYCLE XXX
  66.          */
  67.  
  68.         if (CurRegion->rg_Type == RGT_SELLIST || CurRegion->rg_Type == RGT_CYCLE) {
  69.         short cnt;
  70.         MaxNode *mn;
  71.  
  72.         cnt = 0;
  73.         for (mn = GetHead(&CurRegion->rg_ListSet); mn; mn = GetSucc(mn)) {
  74.             ++cnt;
  75.         }
  76.         CurRegion->rg_CycleAry = zalloc(sizeof(char *) * (cnt + 1));
  77.         cnt = 0;
  78.         for (mn = GetHead(&CurRegion->rg_ListSet); mn; mn = GetSucc(mn)) {
  79.             CurRegion->rg_CycleAry[cnt++] = mn->ln_Name;
  80.         }
  81.         }
  82.         CurRegion = NULL;
  83.         break;
  84.     case PT_NAME:
  85.         {
  86.         char *str;
  87.  
  88.         if (pe.pe_Len >= sizeof(TmpBuf))
  89.             break;
  90.         fread(TmpBuf, pe.pe_Len, 1, fi);
  91.         TmpBuf[pe.pe_Len] = 0;
  92.         str = strdup(TmpBuf);
  93.  
  94.         switch(state) {
  95.         case PT_REGION:
  96.             CurRegion->rg_Node.ln_Name = str;
  97.             break;
  98.         case PT_TEXTATTR:
  99.             CurRegion->rg_TextAttr.ta_Name = str;
  100.             break;
  101.         case PT_DATABASE:
  102.             CurRegion->rg_DataBase = str;
  103.             break;
  104.         case PT_LISTREF:
  105.             CurRegion->rg_ListRef = str;
  106.             break;
  107.         case PT_LISTSET:
  108.             AddNode(&CurRegion->rg_ListSet, str, 0);
  109.             break;
  110.         case PT_DEFTEXT:
  111.             CurRegion->rg_DefText = str;
  112.             break;
  113.         case PT_LABTEXT:
  114.             CurRegion->rg_LabText = str;
  115.             break;
  116.         default:
  117.             free(str);
  118.             break;
  119.         }
  120.         }
  121.         break;
  122.     case PT_BOX:
  123.         {
  124.         Box box;
  125.  
  126.         fread(&box, sizeof(box), 1, fi);
  127.         switch(state) {
  128.         case PT_REGION:
  129.             CurRegion->rg_Box = box;
  130.             break;
  131.         default:
  132.             break;
  133.         }
  134.         }
  135.         break;
  136.     case PT_MINMAX:
  137.         {
  138.         Box box;
  139.  
  140.         fread(&box, sizeof(box), 1, fi);
  141.         switch(state) {
  142.         case PT_REGION:
  143.             CurRegion->rg_MinMax = box;
  144.             break;
  145.         default:
  146.             break;
  147.         }
  148.         }
  149.         break;
  150.     case PT_MAXBUFLEN:
  151.         if (state == PT_REGION) {
  152.         long val;
  153.         fread(&val, sizeof(val), 1, fi);
  154.         CurRegion->rg_MaxBufLen = val;
  155.         }
  156.         break;
  157.     case PT_ID:
  158.         if (state == PT_REGION) {
  159.         long val;
  160.         fread(&val, sizeof(val), 1, fi);
  161.         CurRegion->rg_Id = val;
  162.         }
  163.         break;
  164.     case PT_REGLL:
  165.         if (state == PT_REGION) {
  166.         long val;
  167.         fread(&val, sizeof(val), 1, fi);
  168.         CurRegion->rg_LinkLeft = (TplRegion *)val;
  169.         }
  170.         break;
  171.     case PT_REGLR:
  172.         if (state == PT_REGION) {
  173.         long val;
  174.         fread(&val, sizeof(val), 1, fi);
  175.         CurRegion->rg_LinkRight = (TplRegion *)val;
  176.         }
  177.         break;
  178.     case PT_REGLU:
  179.         if (state == PT_REGION) {
  180.         long val;
  181.         fread(&val, sizeof(val), 1, fi);
  182.         CurRegion->rg_LinkUp = (TplRegion *)val;
  183.         }
  184.         break;
  185.     case PT_REGLD:
  186.         if (state == PT_REGION) {
  187.         long val;
  188.         fread(&val, sizeof(val), 1, fi);
  189.         CurRegion->rg_LinkDown = (TplRegion *)val;
  190.         }
  191.         break;
  192.     case PT_LOCKTO:
  193.         if (state == PT_REGION) {
  194.         long val;
  195.         fread(&val, sizeof(val), 1, fi);
  196.         CurRegion->rg_LockedTo = (TplRegion *)val;
  197.         }
  198.         break;
  199.     case PT_FLAGS:
  200.         if (state == PT_REGION) {
  201.         long val;
  202.         fread(&val, sizeof(val), 1, fi);
  203.         CurRegion->rg_Flags = val;
  204.         }
  205.         break;
  206.     case PT_TYPE:
  207.         if (state == PT_REGION) {
  208.         long val;
  209.         fread(&val, sizeof(val), 1, fi);
  210.         CurRegion->rg_Type = val;
  211.         if (DDebug)
  212.             printf("PT_TYPE VAL %d\n", val);
  213.         }
  214.         break;
  215.     case PT_EXCLID:
  216.         if (state == PT_REGION) {
  217.         long val;
  218.         fread(&val, sizeof(val), 1, fi);
  219.         CurRegion->rg_ExclGroup = val;
  220.         }
  221.         break;
  222.     case PT_DATABASE:
  223.     case PT_LISTREF:
  224.     case PT_LISTSET:
  225.     case PT_DEFTEXT:
  226.     case PT_LABTEXT:
  227.     case PT_TEXTATTR:
  228.         ScanProject(pe.pe_Type, fi, subEndOffset);
  229.         break;
  230.     case PT_YSIZE:
  231.         if (state == PT_TEXTATTR) {
  232.         long val;
  233.         fread(&val, sizeof(val), 1, fi);
  234.         CurRegion->rg_TextAttr.ta_YSize = val;
  235.         }
  236.         break;
  237.     case PT_END:
  238.         return;
  239.     default:
  240.         break;
  241.     }
  242.  
  243.     if (ftell(fi) != subEndOffset)
  244.         fseek(fi, subEndOffset, 0);
  245.     }
  246. }
  247.  
  248. void
  249. ResolveLinks()
  250. {
  251.     TplRegion *rg;
  252.  
  253.     for (rg = GetHead(&RegList); rg; rg = GetSucc(&rg->rg_Node)) {
  254.     if (DDebug)
  255.         printf("TG TYPE %d\n", rg->rg_Type);
  256.     rg->rg_LinkLeft = IdToRegion((long)rg->rg_LinkLeft);
  257.     rg->rg_LinkRight= IdToRegion((long)rg->rg_LinkRight);
  258.     rg->rg_LinkUp    = IdToRegion((long)rg->rg_LinkUp);
  259.     rg->rg_LinkDown = IdToRegion((long)rg->rg_LinkDown);
  260.     rg->rg_LockedTo = IdToRegion((long)rg->rg_LockedTo);
  261.     }
  262. }
  263.  
  264. void
  265. ResolveIDs()
  266. {
  267.     TplRegion *rg;
  268.  
  269.     for (IdNo = 0, rg = GetHead(&RegList); rg; rg = GetSucc(&rg->rg_Node)) {
  270.     rg->rg_Id = ++IdNo;
  271.     }
  272. }
  273.  
  274. void
  275. UnResolveIDs()
  276. {
  277.     TplRegion *rg;
  278.  
  279.     for (IdNo = 0, rg = GetHead(&RegList); rg; rg = GetSucc(&rg->rg_Node)) {
  280.     rg->rg_Id = 0;
  281.     }
  282. }
  283.  
  284.