Пример #1
0
   GMC_DCL(tp_Nod, Nod)
{
   tp_FilHdr FilHdr;
   tp_Nod RootNod, OprNod;
   tp_Key Key;

   if (Nod == ERROR) return ERROR;

   switch (Nod_NodTyp(Nod)) {
      case NSTDEF: case FILDEF: case SEGDEF: {
	 SystemError("Syntax error: Unexpected target.\n");
	 return ERROR; }/*case*/;
      case WORD: {
	 FilHdr = Str_FilHdr(Sym_Str(Nod_Sym(Nod)), NullPrmTyp);
	 return New_PrmFHdr(FilHdr, RootFilPrm); }/*case*/;
      case DRVFIL: {
	 break; }/*case*/;
      default: {
	 FATALERROR("Unexpected node type.\n"); };}/*switch*/;

   RootNod = Nod_Son(1, Nod);
   OprNod = Nod_Brother(RootNod);
   switch (Nod_NodTyp(RootNod)) {
      case EMPFIL: {
	 FilHdr = Copy_FilHdr(EmptyFilHdr);
	 break; }/*case*/;
      case ARTFIL: {
	 FilHdr = Copy_FilHdr(RootFilHdr);
	 break; }/*case*/;
      case OBJTID: {
	 FilHdr = LocHdr_FilHdr
	  ((tp_LocHdr)Str_PosInt(Sym_Str(Nod_Sym(RootNod))));
	 break; }/*case*/;
      case WORD: {
	 FilHdr = HostFN_FilHdr(Sym_Str(Nod_Sym(RootNod)));
	 break; }/*case*/;
      case ABSFIL: {
	 Key = Sym_Str(Nod_Sym(Nod_Son(1, RootNod)));
	 FilHdr = Do_Keys(Copy_FilHdr(RootFilHdr), Key);
	 break; }/*case*/;
      case SEGOPR: {
	 FilHdr = Get_BaseVTgtFilHdr(Top_ContextFilHdr());
	 OprNod = RootNod;
	 break; }/*case*/;
      case DRVOPR: {
	 FilHdr = Top_ContextFilHdr();
	 OprNod = RootNod;
	 break; }/*case*/;
      case STRING: {
	 FilHdr = Str_FilHdr(Sym_Str(Nod_Sym(Nod_Son(1, RootNod))), NullPrmTyp);
	 break; }/*case*/;
      default: {
	 FATALERROR("Unexpected node type.\n"); };}/*switch*/;

   return Apply_OprNods(FilHdr, RootFilPrm, OprNod);
   }/*Nod_PrmFHdr*/
Пример #2
0
   GMC_DCL(tp_FilHdr, FilHdr)
{
   tp_FilHdr DestElmFH, OrigElmFH;
   tp_LocElm LocElm;
   tp_FilElm FilElm;
   tps_Str StrBuf;

   if (FilHdr_Flag(OrigFilHdr, FLAG_Union)) {
      return; }/*if*/;
   Set_Flag(OrigFilHdr, FLAG_Union);

   if (!IsRef(OrigFilHdr)) {
      DestElmFH = Copy_FilHdr(DestFilHdr);
      DestElmFH = Do_Key(DestElmFH, FilHdr_Label(StrBuf, OrigFilHdr, FALSE));
      LocElm = Make_CopyLocElm(OrigFilHdr, DestElmFH, FilHdr);
      Chain_LocElms(FirstLEPtr, LastLEPtr, LocElm);
      Ret_FilHdr(DestElmFH);
      return; }/*if*/;

   for (FilElm = LocElm_FilElm(FilHdr_LocElm(OrigFilHdr));
	FilElm != NIL;
	FilElm = FilElm_NextFilElm(FilElm)) {
      OrigElmFH = FilElm_FilHdr(FilElm);
      Get_CopyList(FirstLEPtr, LastLEPtr, OrigElmFH, DestFilHdr, FilHdr);
      Ret_FilHdr(OrigElmFH); }/*for*/;
   }/*Get_CopyList*/
Пример #3
0
   GMC_DCL(tp_FilHdr, ListFilHdr)
{
   tp_FilHdr ElmFilHdr;
   tp_LocElm LocElm;
   tp_FilElm FilElm;

   if (IsViewSpec(FilHdr)) {
      FilHdr_Error("Illegal view specification argument: %s\n", FilHdr);
      return; }/*if*/;

   if (FilHdr_Flag(FilHdr, FLAG_Union)) {
      return; }/*if*/;
   Set_Flag(FilHdr, FLAG_Union);

   if (!IsRef(FilHdr)) {
      ElmFilHdr = Do_Deriv(Copy_FilHdr(FilHdr), RootFilPrm, FilPrm, FilTyp);
      /*select*/{
	 if (ElmFilHdr != ERROR) {
	    LocElm = Make_LocElm(ElmFilHdr, RootFilPrm, ListFilHdr);
	    Chain_LocElms(FirstLEPtr, LastLEPtr, LocElm);
	    Ret_FilHdr(ElmFilHdr);
	 }else{
	    FilHdr_Error(" from:\n   %s.\n", FilHdr); };}/*select*/;
      return; }/*if*/;

   for (FilElm = LocElm_FilElm(FilHdr_LocElm(FilHdr));
	FilElm != NIL;
	FilElm = FilElm_NextFilElm(FilElm)) {
      ElmFilHdr = FilElm_FilHdr(FilElm);
      Get_Map(FirstLEPtr, LastLEPtr, ElmFilHdr,
	      Append_FilPrm(FilElm_FilPrm(FilElm), FilPrm),
	      FilTyp, ListFilHdr);
      Ret_FilHdr(ElmFilHdr); }/*for*/;
   }/*Get_Map*/
Пример #4
0
   GMC_DCL(tp_FilTyp, ToFilTyp)
{
   tp_DrvPth DrvPth, GenericDrvPth;
   boolean IsGeneric;
   tp_FilHdr GenericFilHdr, TmpGenericFilHdr;

   if (FilHdr == ERROR || ToFilTyp == ERROR) return ERROR;

   Do_Search(&DrvPth, &IsGeneric,
	     FilHdr_FKind(FilHdr), FilHdr_FilTyp(FilHdr), ToFilTyp);

   if (IsGeneric) {
      GenericFilHdr = Copy_FilHdr(FilHdr);
      GenericDrvPth = DrvPth;
      while (IsGeneric) {
	 TmpGenericFilHdr = GenericFilHdr;
	 GenericFilHdr = Do_DrvPth(GenericFilHdr, RootFilPrm, RootFilPrm, GenericDrvPth);
	 IsGeneric = FALSE;
	 /*select*/{
	    if (GenericFilHdr == TmpGenericFilHdr) {
	       GenericDrvPth = NIL;
	    }else if (FilHdr_FilTyp(GenericFilHdr) != ToFilTyp) {
	       Do_Search(&GenericDrvPth, &IsGeneric,
			 FilHdr_FKind(GenericFilHdr),
			 FilHdr_FilTyp(GenericFilHdr), ToFilTyp);
	       AppendDrvPth(&DrvPth, GenericDrvPth); };}/*select*/; }/*while*/;
      Ret_FilHdr(GenericFilHdr);
      if (GenericDrvPth == NIL) {
	 Ret_DrvPth(DrvPth);
	 DrvPth = NIL; }/*if*/; }/*if*/;
   return DrvPth;
   }/*Get_DrvPth*/
Пример #5
0
   GMC_DCL(tp_PrmTyp, PrmTyp)
{
   if (strcmp(Str, "") == 0) {
      return Copy_FilHdr(NilStrFilHdr); }/*if*/;
   return Extend_FilHdr(PrmTyp_StrDirFilHdr(PrmTyp), FK_Str,
			ObjectFilTyp, RootFilPrm, Str);
   }/*Str_FilHdr*/
Пример #6
0
   GMC_DCL(tp_FilHdr, FilHdr)
{
   tp_FilHdr ElmFilHdr;
   tp_FilPrm ElmFilPrm;
   tp_LocElm LocElm;

   ElmFilHdr = Copy_FilHdr(OrigFilHdr);
   ElmFilPrm = Append_PrmInf(RootFilPrm, CopyDestPrmTyp,
			     FilHdr_LocHdr(DestFilHdr), (tp_LocPVal)NIL);
   ElmFilHdr = Do_Deriv(ElmFilHdr, RootFilPrm, ElmFilPrm, CopyFilTyp);
   LocElm = Make_LocElm(ElmFilHdr, RootFilPrm, FilHdr);
   Ret_FilHdr(ElmFilHdr);
   return LocElm;
   }/*Make_CopyLocElm*/
Пример #7
0
   GMC_DCL(tp_FileName, FileName)
{
   tp_FilHdr FilHdr, SymLinkFH;

   FilHdr = OdinExpr_FilHdr(FileName);
   if (FilHdr == ERROR) {
      return; }/*if*/;
   if (IsSource(FilHdr)) {
      SymLinkFH = Deref_SymLink(Copy_FilHdr(FilHdr));
      Set_Status(SymLinkFH, STAT_Unknown);
      Ret_FilHdr(SymLinkFH);
      Update_SrcFilHdr(FilHdr, FALSE); }/*if*/;
   Ret_FilHdr(FilHdr);
   }/*Local_Test*/
Пример #8
0
   GMC_DCL(tp_FilHdr, FilHdr)
{
   size_t sz;
   tp_FilHdr OutFilHdr;
   tp_FTName FTName;

   OutFilHdr = Copy_FilHdr(FilHdr);
   if (IsInstance(OutFilHdr)) OutFilHdr = FilHdr_Father(OutFilHdr);
   FTName = FilTyp_ShortFTName(FilHdr_FilTyp(OutFilHdr));
   sz = snprintf(WorkFileName, MAX_FileName, "%s/%s", Job->JobDirName, FTName);
   if (sz >= MAX_FileName) {
      (void)fprintf(stderr, "File name too long (MAX_FileName=%d): %s/%s\n",
		  MAX_FileName, Job->JobDirName, FTName);
      exit(11); }/*if*/;
   Ret_FilHdr(OutFilHdr);
   }/*Get_WorkFileName*/
Пример #9
0
   GMC_DCL(tp_FileName, OprFileName)
{
   tps_Str StrBuf, StrSegBuf;
   tp_Str Str;
   tp_FilDsc FilDsc;
   int StrLen, LineNum;
   tp_Nod Nod;
   tp_PrmFHdr PrmFHdr;
   tp_FilPrm FilPrm, ElmFilPrm;
   tp_FilHdr ElmFilHdr;
   tp_LocElm LocElm;

   LocElm = NIL;
   FilDsc = FileName_RFilDsc(OprFileName, FALSE);
   if (FilDsc == ERROR) {
      SystemError("Cannot read %s.\n", OprFileName);
      return LocElm; }/*if*/;
   (void)strcpy(StrBuf, ".");
   StrLen = strlen(StrBuf);
   for (Str = ReadLine(StrSegBuf, FilDsc);
	Str != NIL;
	Str = ReadLine(StrSegBuf, FilDsc)) {
      (void)strcat(Str, "\n");
      StrLen += strlen(Str);
      if (StrLen >= MAX_Str) {
	 SystemError("%s: parameter file too long.\n", OprFileName);
	 return LocElm; }/*if*/;
      (void)strcat(StrBuf, Str); }/*for*/;
   Close(FilDsc);
   LineNum = 0;
   Nod = YY_Parser(StrBuf, OprFileName, &LineNum);
   if (Nod == ERROR) {
      return LocElm; }/*if*/;
   FilPrm = StripExcept_FilPrm(FilHdr_FilPrm(FilHdr), ApplyPrmTyp);
   PrmFHdr = Apply_OprNods(Copy_FilHdr(InFilHdr), FilPrm,
			   Nod_Brother(Nod_Son(1, Nod)));
   Ret_Nod(Nod);
   Use_PrmFHdr(&ElmFilHdr, &ElmFilPrm, PrmFHdr);
   if (ElmFilHdr == NIL) {
      return LocElm; }/*if*/;
   LocElm = Make_LocElm(ElmFilHdr, ElmFilPrm, FilHdr);
   Ret_FilHdr(ElmFilHdr);
   return LocElm;
   }/*Make_ApplyLocElm*/
Пример #10
0
   GMC_DCL(tp_Key, Key)
{
   tp_FilHdr DirFilHdr, DirSymFilHdr, SymDirFilHdr;
   tp_FilTyp FilTyp;
   tp_FKind FKind;

   if (FilHdr == ERROR || Key == ERROR) {
      Ret_FilHdr(FilHdr);
      return ERROR; }/*if*/;

   if (strcmp(Key, ".") == 0) {
      return FilHdr; }/*if*/;

   if (strcmp(Key, "") == 0
       && !(FilHdr == RootFilHdr || FilHdr == NetRootFilHdr)) {
      return FilHdr; }/*if*/;

   if (IsSource(FilHdr)) {
      if (strcmp(Key, "..") == 0) {
	 if (FilHdr == RootFilHdr) {
	    return FilHdr; }/*if*/;
	 DirFilHdr = FilHdr_Father(Copy_FilHdr(FilHdr));
	 if (DirFilHdr == NetRootFilHdr) {
	    Ret_FilHdr(DirFilHdr);
	    return FilHdr; }/*if*/;
	 DirSymFilHdr = FilHdr_Father(Deref_SymLink(Copy_FilHdr(FilHdr)));
	 SymDirFilHdr = Deref_SymLink(Copy_FilHdr(DirFilHdr));
	 Ret_FilHdr(FilHdr);
	 if (DirSymFilHdr == SymDirFilHdr) {
	    Ret_FilHdr(DirSymFilHdr); Ret_FilHdr(SymDirFilHdr);
	    return DirFilHdr; }/*if*/;
	 Ret_FilHdr(DirFilHdr); Ret_FilHdr(SymDirFilHdr);
	 return FilHdr_AliasFilHdr(DirSymFilHdr); }/*if*/;

      if (FilHdr == CacheDirFilHdr) {
	 if (strlen(Key) == 1) {
	    return FilHdr; }/*if*/;
	 Ret_FilHdr(FilHdr);
	 return CacheFileName_FilHdr(Key); }/*if*/;

      return Get_KeyDrv(FilHdr, FK_SrcReg, Key); }/*if*/;

   if (IsVirDir(FilHdr)) {
      return Get_KeyDrv(FilHdr, FK_VirDirElm, Key); }/*if*/;

   if (IsTargets(FilHdr)) {
      return Get_KeyDrv(FilHdr, FK_ActTgtText, Key); }/*if*/;

   if (IsPntr(FilHdr)) {
      return Get_Drv(FilHdr, FK_PntrElm, Key_FilTyp(Key), RootFilPrm, Key);
      }/*if*/;

   if (IsDrvDirElm(FilHdr)) {
      return Get_KeyDrv(FilHdr, FK_DrvDirElm, Key); }/*if*/;

   if (!IsKeyList(FilHdr)) {
      FilHdr_Error("Cannot select from <%s>.\n", FilHdr);
      Ret_FilHdr(FilHdr);
      return ERROR; }/*if*/;

   FilTyp = FilHdr_FilTyp(FilHdr);
   /*select*/{
      if (FilTyp == ActTargetsFilTyp) {
	 FKind = FK_ActTgt;
      }else if (FilTyp == VirTargetsFilTyp) {
	 FKind = FK_VirTgt;
      }else{
         FKind = FK_DrvDirElm; };}/*select*/;
   return Get_KeyDrv(FilHdr, FKind, Key);
   }/*Do_Key*/
Пример #11
0
   GMC_DCL(tp_Date, DepModDate)
{
   tps_ExecSpc _ExecSpc; tp_ExecSpc ExecSpc = &_ExecSpc;
   tp_Job Job;
   tp_Tool Tool;
   tp_TClass TClass;
   tp_InpFilHdrs Inputs;
   tp_OutFilHdrs Outputs;
   tp_FileName OldErrFileName;
   tp_FilDsc OldErrFD;
   tps_FileName InFileName, OutFileName;
   tps_Str StrBuf;
   tp_FilDsc InFD, OutFD;
   tp_Status MinStatus;
   tp_FilHdr ElmFilHdr, DestFilHdr, OprFilHdr;
   tp_LocElm LocElm, FirstLE, LastLE;
   tp_FilElm FilElm;
   int i;
   boolean ErrFlag, OldIsIPC;

   Do_Log("Generating", FilHdr, LOGLEVEL_IntGenerate);
   MinStatus = DepStatus;

   Tool = FilHdr_Tool(FilHdr);
   FilHdr_ExecSpc(ExecSpc, FilHdr);
   Job = New_Job();
   ExecSpc->Job = Job;
   Inputs = ExecSpc->InpFilHdrs;
   Outputs = ExecSpc->OutFilHdrs;

   Save_ErrFile(&OldErrFileName, &OldIsIPC, &OldErrFD);
   Set_ErrFile(Job->ErrorFN, FALSE, (tp_FilDsc)NIL);
   Clr_ErrStatus(FilHdr);

   TClass = Tool_TClass(Tool);
   switch (TClass) {
      case TC_Str: {
	 break;}/*case*/;
      case TC_StructMem: {
	 FATALERROR("StructMem's should always be up-to-date");
	 break;}/*case*/;
      case TC_PrmValues: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 FirstLE = NIL; LastLE = NIL;
	 FilPVal_LocElm(&FirstLE, &LastLE,
			FilPrm_FilPVal(FilHdr_FilPrm(FilHdr)), FilHdr);
	 Set_LocElm(FilHdr, FirstLE);
	 break;}/*case*/;
      case TC_First: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 /*select*/{
	    if (FilHdr_LocElm(Inputs[0]) == 0) {
	       LocElm = Make_LocElm(NilStrFilHdr, RootFilPrm, FilHdr);
	    }else{
	       FilElm = LocElm_FilElm(FilHdr_LocElm(Inputs[0]));
	       ElmFilHdr = FilElm_FilHdr(FilElm);
	       Ret_FilElm(FilElm);
	       LocElm = Make_LocElm(ElmFilHdr, RootFilPrm, FilHdr);
	       Ret_FilHdr(ElmFilHdr); };}/*select*/;
	 Set_LocElm(FilHdr, LocElm);
	 break;}/*case*/;
      case TC_DrvDirElm: {
	 if (MinStatus > STAT_NoFile) {
	    Add_ErrStatus(FilHdr, STAT_NoFile);
	    MinStatus = STAT_NoFile; }/*if*/;
	 break;}/*case*/;
      case TC_VirDirElm: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 LocElm = 0;
	 ElmFilHdr = Do_Key(FilHdr_Father(Copy_FilHdr(Inputs[0])),
			    FilHdr_Key(StrBuf, FilHdr));
	 if (ElmFilHdr != ERROR) {
	    LocElm = Make_LocElm(ElmFilHdr, RootFilPrm, FilHdr);
	    Ret_FilHdr(ElmFilHdr); }/*if*/;
	 Set_LocElm(FilHdr, LocElm);
	 break;}/*case*/;
      case TC_Collect: {
	 FORBIDDEN(ExecSpc->NumInps < 1 || ExecSpc->NumOuts != 1);
	 FirstLE = NIL; LastLE = NIL;
	 for (i=0; i<ExecSpc->NumInps; i++) {
	    LocElm = Make_LocElm(Inputs[i], FilHdr_FilPrm(FilHdr), FilHdr);
	    Chain_LocElms(&FirstLE, &LastLE, LocElm);
	    }/*for*/;
	 Set_LocElm(FilHdr, FirstLE);
	 if (IsPntr(FilHdr)) Validate_IsPntr(FilHdr);
	 break;}/*case*/;
      case TC_ReadList: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 Exec_List(FilHdr, Inputs[0], FilHdr_FilPrm(FilHdr), FALSE);
	 if (IsPntr(FilHdr)) Validate_IsPntr(FilHdr);
	 break;}/*case*/;
      case TC_SrcNames: case TC_OpNames: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 Get_WorkFileName(OutFileName, Job, FilHdr);
	 OutFD = FileName_WFilDsc(OutFileName, TRUE);
	 FilHdr_DataFileName(InFileName, Inputs[0]);
	 WriteSrcNames(OutFD, InFileName, (TClass == TC_OpNames));
	 Close(OutFD);
	 break;}/*case*/;
      case TC_ViewSpec: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 Exec_List(FilHdr, Inputs[0], RootFilPrm, FALSE);
	 Validate_ViewSpec(FilHdr);
	 break;}/*case*/;
      case TC_CmptView: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 Exec_CmptView(&ErrFlag, FilHdr, Inputs[0]);
	 if (ErrFlag) {
	    Add_ErrStatus(FilHdr, STAT_TgtValError);
	    if (MinStatus > STAT_TgtValError) {
	       MinStatus = STAT_TgtValError; }/*if*/; }/*if*/;
	 break;}/*case*/;
      case TC_Directory: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 ElmFilHdr = FilHdr_DirFilHdr(Copy_FilHdr(Inputs[0]));
	 Set_LocElm(FilHdr, Make_LocElm(ElmFilHdr, RootFilPrm, FilHdr));
	 Ret_FilHdr(ElmFilHdr);
	 break;}/*case*/;
      case TC_Name: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 Get_WorkFileName(OutFileName, Job, FilHdr);
	 OutFD = FileName_WFilDsc(OutFileName, TRUE);
	 WritePrmOdinExpr(OutFD, Inputs[0], FilHdr_FilPrm(FilHdr));
	 Close(OutFD);
	 break;}/*case*/;
      case TC_Names: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 Get_WorkFileName(OutFileName, Job, FilHdr);
	 OutFD = FileName_WFilDsc(OutFileName, TRUE);
	 WriteNames(OutFD, Inputs[0], FilHdr_FilPrm(FilHdr));
	 Close(OutFD);
	 break;}/*case*/;
      case TC_FileName: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 /*select*/{
	    if (IsAtmc(Inputs[0])) {
	       Get_WorkFileName(OutFileName, Job, FilHdr);
	       OutFD = FileName_WFilDsc(OutFileName, TRUE);
	       FilHdr_DataFileName(InFileName, Inputs[0]);
	       Writeln(OutFD, InFileName);
	       Close(OutFD);
	    }else{
	       FilHdr_Error("Input to :filename must be atomic: <%s>.\n",
			    Inputs[0]); };}/*select*/;
	 break;}/*case*/;
      case TC_FileNames: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 Get_WorkFileName(OutFileName, Job, FilHdr);
	 OutFD = FileName_WFilDsc(OutFileName, TRUE);
	 WriteFlat(OutFD, Inputs[0]);
	 Close(OutFD);
	 break;}/*case*/;
      case TC_Cat: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 Get_WorkFileName(OutFileName, Job, FilHdr);
	 OutFD = FileName_WFilDsc(OutFileName, TRUE);
	 WriteCat(OutFD, Inputs[0]);
	 Close(OutFD);
	 break;}/*case*/;
      case TC_Union: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 Set_LocElm(FilHdr, Make_UnionLocElm(Inputs[0], FilHdr));
	 break;}/*case*/;
      case TC_PntrHo: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 Set_LocElm(FilHdr, Make_PntrHoLocElm(Inputs[0], FilHdr));
	 break;}/*case*/;
      case TC_Apply: {
	 FORBIDDEN(ExecSpc->NumInps != 2 || ExecSpc->NumOuts != 1);
	 OprFilHdr = Deref(Copy_FilHdr(Inputs[1]));
	 FilHdr_DataFileName(InFileName, OprFilHdr);
	 Push_ContextFilHdr(OprFilHdr);
	 Set_LocElm(FilHdr, Make_ApplyLocElm(Inputs[0], FilHdr, InFileName));
	 Pop_ContextFilHdr();
	 break;}/*case*/;
      case TC_DerefPrmVal: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 Set_LocElm(FilHdr, Make_DerefPrmValLocElm(Inputs[0], FilHdr));
	 break;}/*case*/;
      case TC_Map: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 Set_LocElm(FilHdr, Make_MapLocElm(Inputs[0], FilHdr));
	 break;}/*case*/;
      case TC_Recurse: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 Set_LocElm(FilHdr, Make_RecurseLocElm(Inputs[0], FilHdr));
	 break;}/*case*/;
      case TC_Extract: case TC_Delete: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 Set_LocElm(FilHdr, Make_ExDelLocElm(Inputs[0], FilHdr,
					     (TClass == TC_Extract)));
	 break;}/*case*/;
      case TC_PntrElm: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 LocElm = 0;
	 ElmFilHdr = Do_Key(Copy_FilHdr(Inputs[0]), FilHdr_Key(StrBuf, FilHdr));
	 if (ElmFilHdr != ERROR) {
	    LocElm = Make_LocElm(ElmFilHdr, RootFilPrm, FilHdr);
	    Ret_FilHdr(ElmFilHdr); }/*if*/;
	 Set_LocElm(FilHdr, LocElm);
	 break;}/*case*/;
      case TC_Error: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 Get_WorkFileName(OutFileName, Job, FilHdr);
	 OutFD = FileName_WFilDsc(OutFileName, TRUE);
	 WriteReport(OutFD, Inputs[0], STAT_TgtValError);
	 Close(OutFD);
	 break;}/*case*/;
      case TC_Warning: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 Get_WorkFileName(OutFileName, Job, FilHdr);
	 OutFD = FileName_WFilDsc(OutFileName, TRUE);
	 WriteReport(OutFD, Inputs[0], STAT_Warning);
	 Close(OutFD);
	 break;}/*case*/;
      case TC_Label: {
	 Get_WorkFileName(OutFileName, Job, FilHdr);
	 OutFD = FileName_WFilDsc(OutFileName, TRUE);
	 Writeln(OutFD, FilHdr_Label(StrBuf, Inputs[0], FALSE));
	 Close(OutFD);
	 break;}/*case*/;
      case TC_Labels: {
	 FORBIDDEN(!IsList(Inputs[0]));
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 Get_WorkFileName(OutFileName, Job, FilHdr);
	 OutFD = FileName_WFilDsc(OutFileName, TRUE);
	 WriteLabels(OutFD, Inputs[0]);
	 Close(OutFD);
	 break;}/*case*/;
      case TC_Id: {
	 Get_WorkFileName(OutFileName, Job, FilHdr);
	 OutFD = FileName_WFilDsc(OutFileName, TRUE);
	 WriteInt(OutFD, (int)FilHdr_LocHdr(Inputs[0]));
	 Writeln(OutFD, "");
	 Close(OutFD);
	 break;}/*case*/;
      case TC_Depend: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 FirstLE = NIL; LastLE = NIL;
	 GetDepend(&FirstLE, &LastLE, Inputs[0], FilHdr);
	 Set_LocElm(FilHdr, FirstLE);
	 break;}/*case*/;
      case TC_InternalPntr: {
	 break;}/*case*/;
      case TC_TargetsPtr: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 Exec_TargetsPtr(FilHdr, Inputs[0]);
	 break;}/*case*/;
      case TC_TargetsInc: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 Exec_List(FilHdr, Inputs[0], RootFilPrm, TRUE);
	 break;}/*case*/;
      case TC_Targets: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 Get_WorkFileName(OutFileName, Job, FilHdr);
	 OutFD = FileName_WFilDsc(OutFileName, TRUE);
	 FilHdr_DataFileName(InFileName, Inputs[0]);
	 Push_ContextFilHdr(Copy_FilHdr(Inputs[0]));
	 Exec_Targets(OutFD, InFileName);
	 Pop_ContextFilHdr();
	 Close(OutFD);
	 break;}/*case*/;
      case TC_ActTargets: case TC_VirTargets: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 FilHdr_DataFileName(InFileName, Inputs[0]);
	 InFD = FileName_RFilDsc(InFileName, FALSE);
	 LocElm = NIL;
	 if (InFD != NIL) {
	    Push_ContextFilHdr(Copy_FilHdr(FilHdr));
	    LocElm = Make_TargetsLocElm(FilHdr, InFD, InFileName, DepModDate,
					 (TClass == TC_VirTargets));
	    Pop_ContextFilHdr();
	    Close(InFD); }/*if*/;
	 Set_LocElm(FilHdr, LocElm);
	 break;}/*case*/;
      case TC_VirDir: {
	 Exec_VirDir(FilHdr, Inputs[0]);
	 break;}/*case*/;
      case TC_CopyCmd: {
	 DestFilHdr = Deref(LocHdr_FilHdr
	    (FilPVal_LocHdr(FilPrm_FilPVal(FilHdr_FilPrm(FilHdr)))));
	 /*select*/{
	    if (DestFilHdr == ERROR) {
	       SystemError("+copydestdesc=(dest) parameter required.\n");
	    }else{
	       Exec_CopyCmd(FilHdr, DestFilHdr, Inputs[0]);
	       Ret_FilHdr(DestFilHdr); };}/*select*/;
	 break;}/*case*/;
      case TC_ExpandHooks: {
	 FORBIDDEN(ExecSpc->NumInps != 2 || ExecSpc->NumOuts != 1);
	 FilHdr_DataFileName(InFileName, Inputs[1]);
	 InFD = FileName_RFilDsc(InFileName, TRUE);
	 Get_WorkFileName(OutFileName, Job, FilHdr);
	 OutFD = FileName_WFilDsc(OutFileName, TRUE);
	 ExpandHooks(OutFD, InFD, Inputs[0]);
	 Close(InFD); Close(OutFD);
	 break;}/*case*/;
      case TC_NestedHooks: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 2);
	 FilHdr_DataFileName(InFileName, Inputs[0]);
	 InFD = FileName_RFilDsc(InFileName, TRUE);
	 Get_WorkFileName(OutFileName, Job, Outputs[1]);
	 OutFD = FileName_WFilDsc(OutFileName, TRUE);
	 NestedHooks(Outputs[0], Outputs[1], OutFD,
		     InFD, FilHdr_FilPrm(FilHdr));
	 Close(InFD); Close(OutFD);
	 break;}/*case*/;
      case TC_TextDef: {
	 FilHdr_DataFileName(InFileName, Inputs[0]);
	 InFD = FileName_RFilDsc(InFileName, TRUE);
	 Get_WorkFileName(OutFileName, Job, FilHdr);
	 OutFD = FileName_WFilDsc(OutFileName, TRUE);
	 WriteTextDef(FilHdr, OutFD, OutFileName, InFD, InFileName);
	 Close(InFD); Close(OutFD);
	 break;}/*case*/;
      case TC_PrefixHelp: case TC_SuffixHelp: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 Get_WorkFileName(OutFileName, Job, FilHdr);
	 OutFD = FileName_WFilDsc(OutFileName, TRUE);
	 WriteSrcFilTyps(OutFD, (TClass == TC_PrefixHelp));
	 Close(OutFD);
	 break;}/*case*/;
      case TC_DrvHelp: {
	 FORBIDDEN(ExecSpc->NumInps != 1 || ExecSpc->NumOuts != 1);
	 Get_WorkFileName(OutFileName, Job, FilHdr);
	 OutFD = FileName_WFilDsc(OutFileName, TRUE);
	 WriteDrvHelp(OutFD, Inputs[0]);
	 Close(OutFD);
	 break;}/*case*/;
      case TC_PrmHelp: {
	 FORBIDDEN(ExecSpc->NumInps > 2 || ExecSpc->NumOuts != 1);
	 Get_WorkFileName(OutFileName, Job, FilHdr);
	 OutFD = FileName_WFilDsc(OutFileName, TRUE);
	 WritePrmHelp(OutFD, Inputs[0], FilHdr_FilPrm(FilHdr));
	 Close(OutFD);
	 break;}/*case*/;
      default: {
	 FATALERROR("illegal system tool"); }}/*switch*/;

   ErrFlag = IsErr();
   Set_ErrFile(OldErrFileName, OldIsIPC, OldErrFD);
   if (ErrFlag) {
      Add_StatusFile(FilHdr, STAT_Error, Job->ErrorFN);
      if (MinStatus > STAT_Error) {
	 MinStatus = STAT_Error; }/*if*/; }/*if*/;
   if (MinStatus == STAT_Error && IsTargets(FilHdr)) {
      MinStatus = STAT_TgtValError; }/*if*/;

   Do_Update(FilHdr, ExecSpc->OutFilHdrs, ExecSpc->NumOuts, Job,
	     MinStatus, DepModDate, TRUE);

   Ret_Job(Job);
   Ret_ExecSpc(ExecSpc);
   }/*ExecInternal*/