GMC_DCL(tp_FilTyp, ToFilTyp)
{
tp_DrvPth DrvPth;
if (FilHdr == ERROR || InhFilPrm == ERROR || ToFilTyp == ERROR) {
Ret_FilHdr(FilHdr);
return ERROR; }/*if*/;
if (FilHdr_FilTyp(FilHdr) == ToFilTyp) {
if (PrecFilPrm != RootFilPrm) {
Do_Log("Ignoring parameters of", FilHdr, LOGLEVEL_IgnorePrm); }/*if*/;
return FilHdr; }/*if*/;
DrvPth = Get_DrvPth(FilHdr, ToFilTyp);
if (DrvPth == ERROR) {
SystemError("Cannot derive to <%s> from <%s>\n",
FilTyp_FTName(ToFilTyp),
FilTyp_FTName(FilHdr_FilTyp(FilHdr)));
Ret_FilHdr(FilHdr);
return ERROR; }/*if*/;
FilHdr = Do_DrvPth(FilHdr, InhFilPrm, PrecFilPrm, DrvPth);
Ret_DrvPth(DrvPth);
return FilHdr;
}/*Do_Deriv*/
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*/
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*/
GMC_DCL(boolean, IgnoreStatus)
{
tp_FilPrm FilPrm;
tp_FilElm FilElm;
*FilHdrPtr = (tp_FilHdr)NIL;
*FilPrmPtr = (tp_FilPrm)NIL;
if (FilHdr == ERROR) {
return; }/*if*/;
if (FilHdr_Flag(FilHdr, FLAG_DeRef)) {
FilHdr_Error("<%s> is circular.\n", FilHdr);
Ret_FilHdr(FilHdr);
return; }/*if*/;
if (!(IsPntr(FilHdr)
&& (FilHdr_Status(FilHdr) > STAT_Error || IgnoreStatus))) {
*FilHdrPtr = FilHdr;
*FilPrmPtr = RootFilPrm;
return; }/*if*/;
FilElm = LocElm_FilElm(FilHdr_LocElm(FilHdr));
if (IgnoreStatus && FilElm == NIL) {
Ret_FilHdr(FilHdr);
return; }/*if*/;
FORBIDDEN(!IgnoreStatus && (FilElm == NIL || FilElm_Next(FilElm) != NIL));
*FilHdrPtr = FilElm_FilHdr(FilElm);
FilPrm = FilElm_FilPrm(FilElm);
Ret_FilElm(FilElm);
Set_Flag(FilHdr, FLAG_DeRef);
Deref_Pntrs(FilHdrPtr, FilPrmPtr, *FilHdrPtr, IgnoreStatus);
Clr_Flag(FilHdr, FLAG_DeRef);
*FilPrmPtr = Append_FilPrm(*FilPrmPtr, FilPrm);
Ret_FilHdr(FilHdr);
}/*Deref_Pntrs*/
GMC_DCL(tp_DrvPth, DrvPth)
{
tp_DrvPth DrvPthElm, GroupingDrvPthElm;
tp_FilTyp FilTyp;
tp_FKind FKind;
tp_FilPrm FilPrm, DrvFilPrm;
tp_PrmTypLst PrmTypLst;
tps_FileName PkgDirName;
boolean NoInput_Flag=FALSE;
FORBIDDEN(DrvPth == ERROR);
if (FilHdr == ERROR || InhFilPrm == ERROR || PrecFilPrm == ERROR) {
Ret_FilHdr(FilHdr);
return ERROR; }/*if*/;
FilPrm = Append_FilPrm(PrecFilPrm, InhFilPrm);
GroupingDrvPthElm = (PrecFilPrm == RootFilPrm ? NIL
: Find_GroupingDrvPthElm(DrvPth));
for (DrvPthElm = DrvPth;
DrvPthElm != NIL;
DrvPthElm = DrvPth_Next(DrvPthElm)) {
switch (DrvPth_DPType(DrvPthElm)) {
case DPT_Drv: {
FilTyp = DrvPth_FilTyp(DrvPthElm);
FKind = DrvPth_FKind(DrvPthElm);
PrmTypLst = DrvPth_PrmTypLst(DrvPthElm);
/*select*/{
if (IsGroupingInput_FilTyp(FilTyp)) {
DrvFilPrm = FilPrm;
}else if (DrvPthElm == GroupingDrvPthElm) {
DrvFilPrm = Strip_FilPrm(InhFilPrm, PrmTypLst);
DrvFilPrm = Append_FilPrm(PrecFilPrm, DrvFilPrm);
}else{
DrvFilPrm = Strip_FilPrm(FilPrm, PrmTypLst); };}/*select*/;
if (NoInput_Flag) {
FORBIDDEN(FilHdr != ERROR);
Get_PkgDirName(PkgDirName,
Tool_Package(FilTyp_Tool(FilTyp)));
FilHdr = HostFN_FilHdr(PkgDirName);
NoInput_Flag = FALSE; }/*if*/;
FilHdr = Get_Drv(FilHdr, FKind, FilTyp, DrvFilPrm, DfltIdent);
break;}/*case*/;
case DPT_Eqv: {
if (DrvPth_FilTyp(DrvPthElm) == NoInputFilTyp) {
Ret_FilHdr(FilHdr);
FilHdr = ERROR;
NoInput_Flag = TRUE; }/*if*/; break;}/*case*/;
}/*switch*/; }/*for*/;
return FilHdr;
}/*Do_DrvPth*/
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*/
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*/
GMC_DCL(tp_FilPrm, FilPrm)
{
tp_FilHdr ValFilHdr;
tp_FilTyp FilTyp;
tp_DrvPth DrvPth, DrvPthElm;
tp_PrmTypLst PrmTypLst;
Writeln(FilDsc, "*?* Possible Parameters :");
Clr_PrmTypMarks();
if (FilPrm == RootFilPrm) {
SetFilHdr_PrmTypMarks(FilHdr);
WriteMarkedPrmTyps(FilDsc);
return; }/*if*/;
ValFilHdr = LocHdr_FilHdr(FilPVal_LocHdr(FilPrm_FilPVal(FilPrm)));
FilTyp = FTName_FilTyp(FilHdr_Ident(ValFilHdr));
Ret_FilHdr(ValFilHdr);
if (FilTyp == ERROR) {
return; }/*if*/;
if (FilHdr_FilTyp(FilHdr) != FilTyp) {
DrvPth = Get_DrvPth(FilHdr, FilTyp);
if (DrvPth == ERROR) {
SystemError("Cannot derive to <%s>\n", FilTyp_FTName(FilTyp));
return; }/*if*/;
for (DrvPthElm = DrvPth;
DrvPthElm != NIL;
DrvPthElm = DrvPth_Next(DrvPthElm)) {
if (DrvPth_DPType(DrvPthElm) == DPT_Drv) {
PrmTypLst = DrvPth_PrmTypLst(DrvPthElm);
SetPrmTypLst_Marks(PrmTypLst); }/*if*/; }/*for*/;
Ret_DrvPth(DrvPth); }/*if*/;
WriteMarkedPrmTyps(FilDsc);
}/*WritePrmHelp*/
GMC_DCL(tp_PrmTyp, PrmTyp)
{
tp_PrmFHdr PrmFHdr;
tp_FilHdr FilHdr;
tp_FilPrm FilPrm;
tp_LocHdr LocHdr;
if (Nod == ERROR || PrmTyp == ERROR) {
return ERROR; }/*if*/;
switch (Nod_NodTyp(Nod)) {
case DRVFIL: {
PrmFHdr = Nod_PrmFHdr(Nod);
Use_PrmFHdr(&FilHdr, &FilPrm, PrmFHdr);
break;}/*case*/;
case WORD: {
FilHdr = Str_FilHdr(Sym_Str(Nod_Sym(Nod)), PrmTyp);
break;}/*case*/;
default: {
FATALERROR("illegal parameter value node"); };}/*select*/;
if (FilHdr == ERROR) {
return ERROR; }/*if*/;
LocHdr = FilHdr_LocHdr(FilHdr);
Ret_FilHdr(FilHdr);
return LocHdr;
}/*PrmValNod_LocHdr*/
void
End_Get_OdinFile(GMC_ARG_VOID)
{
tp_FilHdr FilHdr;
tps_FileName FileName;
tp_Status Status;
boolean ExecFlag, NeedsData;
FORBIDDEN(Client_ToDo(CurrentClient) != NIL);
FORBIDDEN(Client_Job(CurrentClient) != NIL);
FilHdr = Client_FilHdr(CurrentClient);
FORBIDDEN(FilHdr == NIL);
ExecFlag = IsAutoExec(FilHdr);
NeedsData = ExecFlag || Client_NeedsData(CurrentClient);
Set_Client_FilHdr(CurrentClient, (tp_FilHdr)NIL, FALSE);
(void)strcpy(FileName, "");
Status = STAT_Unknown;
if (Client_Interrupted(CurrentClient)) {
Set_Client_Interrupted(CurrentClient, FALSE);
goto done; }/*if*/;
FilHdr = Deref(FilHdr);
if (FilHdr == ERROR) {
goto done; }/*if*/;
Status = FilHdr_MinStatus(FilHdr, IK_Trans);
if (IsList(FilHdr)) {
goto done; }/*if*/;
if (NeedsData) {
FilHdr_DataFileName(FileName, FilHdr); }/*if*/;
done:;
LocalEnd_Get_OdinFile(FileName, Status, ExecFlag);
Ret_FilHdr(FilHdr);
}/*End_Get_OdinFile*/
GMC_DCL(tp_FilHdr, FilHdr)
{
tp_FilPVal FilPVal;
FilPVal = Get_FilPVal(FilHdr_FilPrm(FilHdr), CopyDestPrmTyp);
Ret_FilHdr(FilHdr);
return LocHdr_FilHdr(FilPVal_LocHdr(FilPVal));
}/*Get_Copy_DestFilHdr*/
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*/
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*/
void
Local_Test_All(GMC_ARG_VOID)
{
tp_Client OldCurrentClient;
tp_FilHdr FilHdr;
boolean AllDone;
CurrentDate += 1;
VerifyDate = CurrentDate;
OldCurrentClient = CurrentClient;
FOREACH_CLIENT(CurrentClient) {
FilHdr = Client_FilHdr(CurrentClient);
if (FilHdr != NIL) {
Ret_ToDo();
Push_AllReqs(&AllDone);
Ret_FilHdr(FilHdr); }/*if*/; }/*for*/;
CurrentClient = OldCurrentClient;
}/*Local_Test_All*/
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*/
GMC_DCL(int, Status)
{
tp_Client Client;
if (IsServer) {
Do_ToBroadcast();
IPC_Finish();
CleanUp();
FOREACH_CLIENT(Client) {
if (!Is_LocalClient(Client)) {
Ret_Client(Client); }/*if*/; }/*for*/;
Purge_Clients();
FORBIDDEN(!Is_LocalClient(CurrentClient));
Ret_Client(CurrentClient);
Purge_Clients();
Ret_FilHdr(RootFilHdr);
Ret_FilHdr(NetRootFilHdr);
Ret_FilHdr(OdinDirFilHdr);
Ret_FilHdr(CacheDirFilHdr);
Ret_FilHdr(PrmDataDirFilHdr);
Ret_FilHdr(StrDirFilHdr);
Ret_FilHdr(NilStrFilHdr);
Ret_FilHdr(FlagPrmFilHdr);
Ret_FilHdr(EmptyFilHdr);
Update_Info();
RetAbsPaths();
Free_FilHdrs();
Free_FilInps();
Free_FilElms();
Close_Info();
FORBIDDEN(PrmFHdrs_InUse());
FORBIDDEN(FilHdrs_InUse());
FORBIDDEN(FilInps_InUse());
FORBIDDEN(FilElms_InUse()); }/*if*/;
exit(Status);
}/*Exit*/
GMC_DCL(boolean, NeedsData)
{
tp_Nod Root;
tp_PrmFHdr PrmFHdr;
tp_FilHdr FilHdr;
tp_FilPrm FilPrm;
boolean AllDone;
Root = YY_Parser(OdinExpr, (tp_FileName)NIL, (int *)NIL);
FORBIDDEN(Root == ERROR);
PrmFHdr = Nod_PrmFHdr(Root);
Ret_Nod(Root);
Use_PrmFHdr(&FilHdr, &FilPrm, PrmFHdr);
if (FilHdr == ERROR) {
LocalEnd_Get_OdinFile("", STAT_Unknown, FALSE);
return; }/*if*/;
Set_Client_FilHdr(CurrentClient, FilHdr, NeedsData);
Push_AllReqs(&AllDone);
Ret_FilHdr(FilHdr);
IsAny_ReadyServerAction = TRUE;
}/*Local_Get_OdinFile*/
void
Write_ENV2(GMC_ARG_VOID)
{
tps_FileName FileName;
tp_FilDsc FilDsc;
tp_Str Str;
tps_Str StrBuf;
tp_EnvVar EnvVar;
int i;
tp_FilHdr FilHdr;
size_t sz;
sz = snprintf(FileName, MAX_FileName, "%s/ENV2", OdinDirName);
if (sz >= MAX_FileName) {
(void)fprintf(stderr, "File name too long (MAX_FileName=%d): %s/ENV2\n",
MAX_FileName, OdinDirName);
exit(1); }/*if*/;
FilDsc = FileName_WFilDsc(FileName, FALSE);
if (FilDsc == ERROR) {
SystemError("Cannot open ENV2 file.\n");
exit(1); }/*if*/;
for (i=0; i<num_EnvVarS; i+=1) {
EnvVar = &EnvVarS[i];
if (EnvVar->IsFile) {
Str = GetEnv(EnvVar->Name);
FORBIDDEN(Str == NIL);
FilHdr = OdinExpr_FilHdr(Str);
if (FilHdr == ERROR) {
SystemError("Value of $%s is not a legal Odin expression.\n",
EnvVar->Name);
exit(1); }/*if*/;
FilHdr_DataFileName(StrBuf, FilHdr);
Ret_FilHdr(FilHdr);
(void)fprintf((FILE *)FilDsc, "%s=%s\1\n", EnvVar->Name, StrBuf);
}/*if*/; }/*for*/;
Close(FilDsc);
}/*Write_ENV2*/
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*/
GMC_DCL(tp_Nod, OprNod)
{
tp_Nod ElmNod;
tp_NodTyp NodTyp;
tp_FilTyp FilTyp;
tp_LocHdr LocHdr;
tp_LocPVal LocPVal;
if (FilHdr == ERROR || FilPrm == ERROR) return ERROR;
while (OprNod != NIL) {
NodTyp = Nod_NodTyp(OprNod);
switch (NodTyp) {
case PRMOPR: {
FilPrm = Append_PrmNod(FilPrm, OprNod);
if (FilPrm == ERROR) {
Ret_FilHdr(FilHdr);
return ERROR; }/*if*/;
break;}/*case*/;
case APLOPR: {
LocHdr = PrmValNod_LocHdr(Nod_Son(1, OprNod), ApplyPrmTyp);
if (LocHdr == ERROR) {
Ret_FilHdr(FilHdr);
return ERROR; }/*if*/;
LocPVal = NIL;
FilPrm = Append_PrmInf(FilPrm, ApplyPrmTyp, LocHdr, LocPVal);
FilHdr = Extend_FilHdr(FilHdr, FK_User, ApplyFilTyp, FilPrm,
DfltIdent);
FilPrm = RootFilPrm;
if (FilHdr == ERROR) {
return ERROR; }/*if*/;
break;}/*case*/;
case DRVOPR: {
FilTyp = Nod_FilTyp(Nod_Son(1, OprNod));
/*select*/{
if (FilTyp == ObjectFilTyp) {
}else if (FilTyp == FatherFilTyp) {
if (!IsInstance(FilHdr)) {
FilHdr_Error("Input to :abstract must be an instance: %s\n", FilHdr);
Ret_FilHdr(FilHdr);
return ERROR; }/*if*/;
FilHdr = FilHdr_Father(FilHdr);
}else{
FilHdr = Do_Deriv(FilHdr, RootFilPrm, FilPrm, FilTyp);
FilPrm = RootFilPrm;
if (FilHdr == ERROR) {
return ERROR; }/*if*/; };}/*select*/;
break;}/*case*/;
case HODOPR: {
FilTyp = Nod_FilTyp(OprNod);
FilHdr = Do_Deriv(FilHdr, RootFilPrm, FilPrm, FilTyp);
if (FilHdr == ERROR) {
return ERROR; }/*if*/;
FilPrm = RootFilPrm;
break;}/*case*/;
case ELMOPR: {
ElmNod = Nod_Son(1, OprNod);
FilPrm = RootFilPrm;
FilHdr = Do_Key(FilHdr, "");
FilHdr = Do_Keys(FilHdr, Sym_Str(Nod_Sym(ElmNod)));
if (FilHdr == ERROR) {
return ERROR; }/*if*/;
break;}/*case*/;
case DIROPR: {
FilHdr = Do_Key(FilHdr, "");
break;}/*case*/;
case SEGOPR: {
FilHdr = Do_VTgt(FilHdr, Sym_Str(Nod_Sym(Nod_Son(1, OprNod))));
FilPrm = RootFilPrm;
break;}/*case*/;
default: {
FATALERROR("bad operator node type"); };}/*switch*/;
OprNod = Nod_Brother(OprNod); }/*while*/;
return New_PrmFHdr(FilHdr, FilPrm);
}/*Apply_OprNods*/
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*/