home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_disks / 500-599 / ff583.lza / TplEdit / src.lzh / load.c < prev    next >
C/C++ Source or Header  |  1991-12-03  |  7KB  |  385 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. /***********************  LoadProject(name) **************************/
  15. void
  16. LoadProject(name)
  17.   char  *name;
  18. {
  19.   FILE  *fi;
  20.  
  21.   UnResolveIDs();
  22.   if ((fi = fopen(name, "r")) == NULL)
  23.   {
  24.     printf("unable to open %s\n", name);
  25.     return;
  26.   }
  27.   ScanProject(0, fi, -1);
  28.   fclose(fi);
  29.   ResolveIDs();
  30. }
  31.  
  32. /***********************  ScanProject(state,  ************************/
  33. void
  34. ScanProject(state, fi, endOffset)
  35.   short  state;
  36.   FILE  *fi;
  37.   long   endOffset;
  38. {
  39.   ProjEntry pe;
  40.   long   subEndOffset;
  41.  
  42.   while (ftell(fi) != endOffset)
  43.   {
  44.     if (fread(&pe, sizeof(pe), 1, fi) != 1)
  45.       return;
  46.  
  47.     subEndOffset = ftell(fi) + pe.pe_Len;
  48.  
  49.     if (DDebug)
  50.       printf("TYPE %d ENDS %08lx\n", pe.pe_Type, subEndOffset);
  51.  
  52.     switch (pe.pe_Type)
  53.     {
  54.     case PT_PROJECT:
  55.       ScanProject(pe.pe_Type, fi, subEndOffset);
  56.       ResolveLinks();
  57.       break;
  58.  
  59.     case PT_HEADER:
  60.       fread(&Ph, pe.pe_Len, 1, fi);
  61.       break;
  62.  
  63.     case PT_REGION:
  64.       if (CurRegion)
  65.       {
  66.         puts("ScanError: region in region!");
  67.         break;
  68.  
  69.       }
  70.       CurRegion = AllocTplRegion();
  71.       ScanProject(pe.pe_Type, fi, subEndOffset);
  72.  
  73. /*
  74.  * Handle list copy if RGT_CYCLE XXX
  75.  */
  76.  
  77.       if (CurRegion->rg_Type == RGT_LISTVIEW ||
  78.           CurRegion->rg_Type == RGT_CYCLE   ||
  79.           CurRegion->rg_Type == RGT_MX)
  80.       {
  81.         short  cnt;
  82.         MaxNode *mn;
  83.  
  84.         cnt = 0;
  85.         for (mn = GetHead(&CurRegion->rg_ListSet); mn; mn = GetSucc(mn))
  86.           ++cnt;
  87.  
  88.         CurRegion->rg_CycleAry = zalloc(sizeof(char *)* (cnt + 1));
  89.         cnt = 0;
  90.         for (mn = GetHead(&CurRegion->rg_ListSet); mn; mn = GetSucc(mn))
  91.           CurRegion->rg_CycleAry[cnt++] = mn->ln_Name;
  92.       }
  93.  
  94.       CurRegion = NULL;
  95.       break;
  96.  
  97.     case PT_NAME:
  98.       {
  99.         char  *str;
  100.  
  101.         if (pe.pe_Len >= sizeof(TmpBuf))
  102.           break;
  103.  
  104.         fread(TmpBuf, pe.pe_Len, 1, fi);
  105.         TmpBuf[pe.pe_Len] = 0;
  106.         str = strdup(TmpBuf);
  107.  
  108.         switch (state)
  109.         {
  110.         case PT_REGION:
  111.           CurRegion->rg_Node.ln_Name = str;
  112.           break;
  113.  
  114.         case PT_TEXTATTR:
  115.           CurRegion->rg_TextAttr.ta_Name = str;
  116.           break;
  117.  
  118.         case PT_DATABASE:
  119.           CurRegion->rg_DataBase = str;
  120.           break;
  121.  
  122.         case PT_LISTREF:
  123.           CurRegion->rg_ListRef = str;
  124.           break;
  125.  
  126.         case PT_LISTSET:
  127.           AddNode(&CurRegion->rg_ListSet, str, 0);
  128.           break;
  129.  
  130.         case PT_DEFTEXT:
  131.           CurRegion->rg_DefText = str;
  132.           break;
  133.  
  134.         case PT_LABTEXT:
  135.           CurRegion->rg_LabText = str;
  136.           break;
  137.  
  138.         default:
  139.           free(str);
  140.           break;
  141.  
  142.         }
  143.       }
  144.       break;
  145.  
  146.     case PT_BOX:
  147.       {
  148.         Box    box;
  149.  
  150.         fread(&box, sizeof(box), 1, fi);
  151.         switch (state)
  152.         {
  153.         case PT_REGION:
  154.           CurRegion->rg_Box = box;
  155.           break;
  156.  
  157.         default:
  158.           break;
  159.  
  160.         }
  161.       }
  162.       break;
  163.  
  164.     case PT_MINMAX:
  165.       {
  166.         Box    box;
  167.  
  168.         fread(&box, sizeof(box), 1, fi);
  169.         switch (state)
  170.         {
  171.         case PT_REGION:
  172.           CurRegion->rg_MinMax = box;
  173.           break;
  174.  
  175.         default:
  176.           break;
  177.  
  178.         }
  179.       }
  180.       break;
  181.  
  182.     case PT_MAXBUFLEN:
  183.       if (state == PT_REGION)
  184.       {
  185.         long   val;
  186.  
  187.         fread(&val, sizeof(val), 1, fi);
  188.         CurRegion->rg_BufSpace = val;
  189.       }
  190.       break;
  191.  
  192.     case PT_ID:
  193.       if (state == PT_REGION)
  194.       {
  195.         long   val;
  196.  
  197.         fread(&val, sizeof(val), 1, fi);
  198.         CurRegion->rg_Id = val;
  199.       }
  200.       break;
  201.  
  202.     case PT_REGLL:
  203.       if (state == PT_REGION)
  204.       {
  205.         long   val;
  206.  
  207.         fread(&val, sizeof(val), 1, fi);
  208.         CurRegion->rg_LinkLeft = (TplRegion *) val;
  209.       }
  210.       break;
  211.  
  212.     case PT_REGLR:
  213.       if (state == PT_REGION)
  214.       {
  215.         long   val;
  216.  
  217.         fread(&val, sizeof(val), 1, fi);
  218.         CurRegion->rg_LinkRight = (TplRegion *) val;
  219.       }
  220.       break;
  221.  
  222.     case PT_REGLU:
  223.       if (state == PT_REGION)
  224.       {
  225.         long   val;
  226.  
  227.         fread(&val, sizeof(val), 1, fi);
  228.         CurRegion->rg_LinkUp = (TplRegion *) val;
  229.       }
  230.       break;
  231.  
  232.     case PT_REGLD:
  233.       if (state == PT_REGION)
  234.       {
  235.         long   val;
  236.  
  237.         fread(&val, sizeof(val), 1, fi);
  238.         CurRegion->rg_LinkDown = (TplRegion *) val;
  239.       }
  240.       break;
  241.  
  242.     case PT_LOCKTO:
  243.       if (state == PT_REGION)
  244.       {
  245.         long   val;
  246.  
  247.         fread(&val, sizeof(val), 1, fi);
  248.         CurRegion->rg_LockedTo = (TplRegion *) val;
  249.       }
  250.       break;
  251.  
  252.     case PT_FLAGS:
  253.       if (state == PT_REGION)
  254.       {
  255.         long   val;
  256.  
  257.         fread(&val, sizeof(val), 1, fi);
  258.         CurRegion->rg_Flags = val;
  259.       }
  260.       break;
  261.  
  262.     case PT_TYPE:
  263.       if (state == PT_REGION)
  264.       {
  265.         long   val;
  266.  
  267.         fread(&val, sizeof(val), 1, fi);
  268.         CurRegion->rg_Type = val;
  269.         if (DDebug)
  270.           printf("PT_TYPE VAL %d\n", val);
  271.       }
  272.       break;
  273.  
  274.     case PT_EXCLID:
  275.       if (state == PT_REGION)
  276.       {
  277.         long   val;
  278.  
  279.         fread(&val, sizeof(val), 1, fi);
  280.         CurRegion->rg_ExclGroup = val;
  281.       }
  282.       break;
  283.  
  284.     case PT_SPECFLAGS:
  285.       if (state == PT_REGION)
  286.       {
  287.         long   val;
  288.  
  289.         fread(&val, sizeof(val), 1, fi);
  290.         CurRegion->rg_SpecFlags = val;
  291.         if (DDebug)
  292.           printf("PT_ACTIVATED VAL %d\n", val);
  293.       }
  294.       break;
  295.  
  296.     case PT_MAXVAL:
  297.       if (state == PT_REGION)
  298.       {
  299.         long   val;
  300.  
  301.         fread(&val, sizeof(val), 1, fi);
  302.         CurRegion->rg_MaxVal = val;
  303.       }
  304.       break;
  305.  
  306.     case PT_DEFVAL:
  307.       if (state == PT_REGION)
  308.       {
  309.         long   val;
  310.  
  311.         fread(&val, sizeof(val), 1, fi);
  312.         CurRegion->rg_DefVal = val;
  313.       }
  314.       break;
  315.  
  316.     case PT_DATABASE:
  317.     case PT_LISTREF:
  318.     case PT_LISTSET:
  319.     case PT_DEFTEXT:
  320.     case PT_LABTEXT:
  321.     case PT_TEXTATTR:
  322.       ScanProject(pe.pe_Type, fi, subEndOffset);
  323.       break;
  324.  
  325.     case PT_YSIZE:
  326.       if (state == PT_TEXTATTR)
  327.       {
  328.         long   val;
  329.  
  330.         fread(&val, sizeof(val), 1, fi);
  331.         CurRegion->rg_TextAttr.ta_YSize = val;
  332.       }
  333.       break;
  334.  
  335.     case PT_END:
  336.       return;
  337.  
  338.     default:
  339.       break;
  340.  
  341.     }
  342.  
  343.     if (ftell(fi) != subEndOffset)
  344.       fseek(fi, subEndOffset, 0);
  345.   }
  346. }
  347.  
  348. /***********************  ResolveLinks()  ****************************/
  349. void
  350. ResolveLinks()
  351. {
  352.   TplRegion *rg;
  353.  
  354.   for (rg = GetHead(&RegList); rg; rg = GetSucc(&rg->rg_Node))
  355.   {
  356.     if (DDebug)
  357.       printf("TG TYPE %d\n", rg->rg_Type);
  358.     rg->rg_LinkLeft   = IdToRegion((long) rg->rg_LinkLeft);
  359.     rg->rg_LinkRight  = IdToRegion((long) rg->rg_LinkRight);
  360.     rg->rg_LinkUp     = IdToRegion((long) rg->rg_LinkUp);
  361.     rg->rg_LinkDown   = IdToRegion((long) rg->rg_LinkDown);
  362.     rg->rg_LockedTo   = IdToRegion((long) rg->rg_LockedTo);
  363.   }
  364. }
  365.  
  366. /***********************  ResolveIDs()  ******************************/
  367. void
  368. ResolveIDs()
  369. {
  370.   TplRegion *rg;
  371.  
  372.   for (IdNo = 0, rg = GetHead(&RegList); rg; rg = GetSucc(&rg->rg_Node))
  373.     rg->rg_Id = ++IdNo;
  374. }
  375.  
  376. /***********************  UnResolveIDs()  ****************************/
  377. void
  378. UnResolveIDs()
  379. {
  380.   TplRegion *rg;
  381.  
  382.   for (IdNo = 0, rg = GetHead(&RegList); rg; rg = GetSucc(&rg->rg_Node))
  383.     rg->rg_Id = 0;
  384. }
  385.