1041 lines
30 KiB
INI
1041 lines
30 KiB
INI
;--------------------------------------
|
|
; HARDWARE OPTION CLASSES WE UNDERSTAND
|
|
;--------------------------------------
|
|
|
|
[Options]
|
|
;
|
|
Computer = cpt
|
|
Video = vio
|
|
Layout = lay
|
|
Language = lng
|
|
Printer = prn
|
|
Sound = snd
|
|
Driver = drv
|
|
NetAdapter = nad
|
|
NetDriver = ndr
|
|
NetTransport = nxp
|
|
NetService = nsv
|
|
Network = nwk
|
|
NetProvider = npr
|
|
|
|
|
|
[OemOptionFiles]
|
|
OemFiles = {} ? $(!LIBHANDLE) FindFileInstances $(!STF_WINDOWSSYSPATH)"\oem"$(Abb)"*.inf"
|
|
|
|
[DetectFileTime]
|
|
FileDateTime = {"0","0"} ? $(!LIBHANDLE) GetFileLastWriteTime $(!STF_WINDOWSSYSPATH)"\"$(FileDateTimeName)
|
|
|
|
|
|
;-----------------------------------------------------------------------
|
|
;
|
|
; ROUTINE: ReturnOemOptions
|
|
;
|
|
; DESCRIPTION: This routine finds out if an OEM file representing
|
|
; the option exists in the windows sytem directory
|
|
; and returns the options represented in the INF.
|
|
;
|
|
; INPUTS: $0: Language to use
|
|
; $1: Option Type (Computer|Video|...)
|
|
;
|
|
; OUTPUTS: $R0: STATUS: STATUS_SUCCESSFUL |
|
|
; STATUS_FAILED
|
|
;
|
|
; $R1: OemOptionList: This is of form:
|
|
; { {Oemfile1, Option1List, Option1TextList},
|
|
; {Oemfile2, Option2List, Option2TextList},
|
|
; ...
|
|
; }
|
|
;
|
|
;
|
|
;------------------------------------------------------------------------
|
|
|
|
[ReturnOemOptions]
|
|
;
|
|
; Initialize
|
|
;
|
|
set Status = STATUS_FAILED
|
|
set OemOptionList = {}
|
|
set FromNetwork = $($2)
|
|
set AllChars = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789."
|
|
set Numerals = { "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" }
|
|
set Abb = #(Options, $($1), 1)
|
|
|
|
read-syms OemOptionFiles
|
|
detect OemOptionFiles
|
|
|
|
ifcontains(i) "oemnadzz.inf" in $(OemFiles)
|
|
;
|
|
; Put oemnadzz.inf at the beginning
|
|
;
|
|
set newList = {"oemnadzz.inf"}
|
|
ForListDo $(OemFiles)
|
|
ifstr(i) $($) != "oemnadzz.inf"
|
|
set newList = >($(newList),$($))
|
|
endif
|
|
EndForListDo
|
|
;set newList = >($(newList),"oemnadzz.inf")
|
|
set OemFiles = $(newList)
|
|
endif
|
|
debug-output $(OemFiles)
|
|
|
|
set TotalOptions = {}
|
|
ForListDo $(OemFiles)
|
|
set fExclude = ""
|
|
|
|
Split-String $($) $(AllChars) InfNameChars
|
|
|
|
ifcontains(i) *($(InfNameChars), 7) in $(Numerals)
|
|
; exclude if from network and a numerical item (thus a real net Oem)
|
|
;
|
|
set fExclude = $(FromNetwork)
|
|
endif
|
|
ifstr(i) $(fExclude) == ""
|
|
set OemFileName = $(!STF_WINDOWSSYSPATH)"\"$($)
|
|
ifstr(i) $(FromNetwork) == ""
|
|
shell "", GetOptionsFromINF $($0) $($1) $(OemFileName)
|
|
else
|
|
shell "", GetNetworkOptionsFromINF $($0) $($1) $(OemFileName)
|
|
endif
|
|
set CurrentInf = $($)
|
|
ifstr(i) $($R0) == STATUS_SUCCESSFUL
|
|
set Index = 0
|
|
set ReturnOption = $($R1)
|
|
set ReturnOptionText = $($R2)
|
|
ForListDo $(ReturnOption)
|
|
set-add Index = $(Index), 1
|
|
ifcontains(i) $($) not-in $(TotalOptions)
|
|
set OemOptionList = >($(OemOptionList), {$(CurrentInf), $($), *($(ReturnOptionText),$(Index))})
|
|
set TotalOptions = >($(TotalOptions), $($))
|
|
endif
|
|
EndForListDo
|
|
endif
|
|
endif
|
|
EndForListDo
|
|
set Status = STATUS_SUCCESSFUL
|
|
|
|
finish_GetCurrentOemOptions = +
|
|
Return $(Status) $(OemOptionList)
|
|
|
|
|
|
|
|
;-----------------------------------------------------------------------
|
|
;
|
|
; ROUTINE: GetNetworkOptionsFromINF
|
|
;
|
|
; DESCRIPTION: This routine checks to see if the specified file exists
|
|
; and if it is of the right type and gets option info from
|
|
; the INF. It is called for network option only.
|
|
;
|
|
; The different between this function and GetOptionsFromINF
|
|
; is that it will elminiate the dupliication of the same
|
|
; option.
|
|
;
|
|
; INPUTS: $0: Language To use
|
|
; $1: OptionType
|
|
; $2: OptionFileName
|
|
;
|
|
; OUTPUTS: $R0: STATUS: STATUS_SUCCESSFUL |
|
|
; STATUS_INFNOTFOUND |
|
|
; STATUS_FAILED
|
|
;
|
|
; $R1: OptionList
|
|
; $R2: OPtionTextList
|
|
;
|
|
;------------------------------------------------------------------------
|
|
|
|
[GetNetworkOptionsFromINF]
|
|
|
|
;
|
|
; Initialize
|
|
;
|
|
|
|
set Status = STATUS_FAILED
|
|
set OptionList = {}
|
|
set OptionTextList = {}
|
|
|
|
|
|
set FileToCheck = $($2)
|
|
install Install-SeeIfFileIsPresent
|
|
ifstr(i) $(STATUS) != "YES"
|
|
set Status = STATUS_INFNOTFOUND
|
|
goto finish_GetNetworkOptionsFromINF
|
|
endif
|
|
|
|
;
|
|
; See if we have cached this information into the Registry.
|
|
;
|
|
Shell "" GetOptionsFromRegistry $($1) $($2)
|
|
ifstr(i) $($R0) == "STATUS_SUCCESSFUL"
|
|
set OptionList = $($R1)
|
|
set OptionTextList = $($R2)
|
|
set Status = STATUS_SUCCESSFUL
|
|
goto finish_GetNetworkOptionsFromINF
|
|
endif
|
|
|
|
;
|
|
; Check that the INF represents the option we are looking for
|
|
;
|
|
shell $($2) Identify
|
|
ifstr(i) $($R0) == "STATUS_SUCCESSFUL"
|
|
ifstr(i) $($R1) == $($1)
|
|
set OptionList = {}
|
|
set OptionTextList = {}
|
|
forlistdo $(!STF_BUSTYPELIST)
|
|
shell $($2) ReturnOptions $($0) $($)
|
|
ifstr(i) $($R0) == STATUS_SUCCESSFUL
|
|
set Index = 0
|
|
set ReturnOption = $($R1)
|
|
set ReturnOptionText = $($R2)
|
|
ForListDo $(ReturnOption)
|
|
set-add Index = $(Index), 1
|
|
ifstr(i) $(OptionList) == {}
|
|
set OptionList = {$($)}
|
|
set OptionTextList = {*($(ReturnOptionText),$(Index))}
|
|
else
|
|
ifcontains(i) $($) not-in $(OptionList)
|
|
set OptionList = >($(OptionList),$($))
|
|
set OptionTextList = >($(OptionTextList),*($(ReturnOptionText),$(Index)))
|
|
endif
|
|
endif
|
|
EndForListDo
|
|
set Status = STATUS_SUCCESSFUL
|
|
endif
|
|
endforlistdo
|
|
ifstr(i) $(OptionList) != ""
|
|
Shell "" SetOptionsIntoRegistry $($1) $($2) $(OptionList) $(OptionTextList)
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
finish_GetNetworkOptionsFromINF = +
|
|
Return $(Status) $(OptionList) $(OptionTextList)
|
|
|
|
;-----------------------------------------------------------------------
|
|
;
|
|
; ROUTINE: GetOptionsFromINF
|
|
;
|
|
; DESCRIPTION: This routine checks to see if the specified file exists
|
|
; and if it is of the right type and gets option info from
|
|
; the INF.
|
|
;
|
|
; INPUTS: $0: Language To use
|
|
; $1: OptionType
|
|
; $2: OptionFileName
|
|
;
|
|
; OUTPUTS: $R0: STATUS: STATUS_SUCCESSFUL |
|
|
; STATUS_INFNOTFOUND |
|
|
; STATUS_FAILED
|
|
;
|
|
; $R1: OptionList
|
|
; $R2: OPtionTextList
|
|
;
|
|
;------------------------------------------------------------------------
|
|
|
|
[GetOptionsFromINF]
|
|
|
|
;
|
|
; Initialize
|
|
;
|
|
|
|
set Status = STATUS_FAILED
|
|
set OptionList = {}
|
|
set OptionTextList = {}
|
|
|
|
|
|
set FileToCheck = $($2)
|
|
install Install-SeeIfFileIsPresent
|
|
ifstr(i) $(STATUS) != "YES"
|
|
set Status = STATUS_INFNOTFOUND
|
|
goto finish_GetOptionsFromINF
|
|
endif
|
|
|
|
;
|
|
; See if we have cached this information into the Registry.
|
|
;
|
|
Shell "" GetOptionsFromRegistry $($1) $($2)
|
|
ifstr(i) $($R0) == "STATUS_SUCCESSFUL"
|
|
set OptionList = $($R1)
|
|
set OptionTextList = $($R2)
|
|
set Status = STATUS_SUCCESSFUL
|
|
goto finish_GetOptionsFromINF
|
|
endif
|
|
|
|
;
|
|
; Check that the INF represents the option we are looking for
|
|
;
|
|
shell $($2) Identify
|
|
ifstr(i) $($R0) == "STATUS_SUCCESSFUL"
|
|
ifstr(i) $($R1) == $($1)
|
|
set OptionList = ""
|
|
shell $($2) ReturnOptions $($0) $($)
|
|
ifstr(i) $($R0) == STATUS_SUCCESSFUL
|
|
set OptionList = $($R1)
|
|
set OptionTextList = $($R2)
|
|
set Status = STATUS_SUCCESSFUL
|
|
endif
|
|
ifstr(i) $(OptionList) != ""
|
|
Shell "" SetOptionsIntoRegistry $($1) $($2) $(OptionList) $(OptionTextList)
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
finish_GetOptionsFromINF = +
|
|
Return $(Status) $(OptionList) $(OptionTextList)
|
|
|
|
|
|
;-----------------------------------------------------------------------
|
|
;
|
|
; ROUTINE: GetNewOEMOption
|
|
;
|
|
; DESCRIPTION: This routine prompts the user for a new OEM file, presents
|
|
; the options supported and if the user chooses one of these
|
|
; copies over the INF to the windows system directory.
|
|
;
|
|
; INPUTS: $0: Language to use
|
|
; $1: OemOptionList
|
|
; $2: OptionType
|
|
; $3: OptDisketteSource
|
|
; $4: Optional Dialog Text
|
|
;
|
|
; OUTPUTS: $R0: STATUS: STATUS_SUCCESSFUL |
|
|
; STATUS_USERCANCEL |
|
|
; STATUS_FAILED |
|
|
;
|
|
; $R1: NewOemOptionList
|
|
; $R2: OemOptionChosen
|
|
; $R3: OemOptionChosenText
|
|
; $R4: OEMINFSource
|
|
;
|
|
;------------------------------------------------------------------------
|
|
|
|
[GetNewOEMOption]
|
|
;
|
|
set Status = STATUS_FAILED
|
|
|
|
set Option = $($2)
|
|
set OptDisketteSrc = $($3)
|
|
set OptionalDlgText = $($4)
|
|
set OptDiskette = #(OptionDiskettes$($0), $($2), 1)
|
|
set InfName1 = "OEMSETUP.INF"
|
|
set InfName2 = "OEMSETNT.INF"
|
|
|
|
set Abb = #(Options, $(Option), 1)
|
|
|
|
set NewOemOptionList = $($1)
|
|
set OptionChosen = ""
|
|
set OptionChosenText = ""
|
|
|
|
;
|
|
; Prompt the user for the diskette containing the INF
|
|
;
|
|
|
|
ask_dodiskette = +
|
|
;
|
|
; Reset the INF name to the standard default
|
|
;
|
|
set InfName = $(InfName1)
|
|
|
|
shell "" DoDiskette $($0) $(OptDiskette) $(OptDisketteSrc)
|
|
set Status = STATUS_FAILED
|
|
|
|
ifstr(i) $($R0) == STATUS_USERCANCEL
|
|
set Status = STATUS_USERCANCEL
|
|
goto finish_GetOEMOption
|
|
else-ifstr(i) $($R0) == STATUS_FAILED
|
|
goto finish_GetOEMOption
|
|
endif
|
|
|
|
set OptDisketteSrc = $($R1)
|
|
|
|
;
|
|
; Check that the Diskette contains an INF we are looking for
|
|
;
|
|
ask_inf_retry = +
|
|
FlushInf $(InfName)
|
|
LibraryProcedure FileToCheck, $(!LIBHANDLE), AppendBackSlash $(OptDisketteSrc)
|
|
set FileToCheck = $(FileToCheck)$(InfName)
|
|
install Install-SeeIfFileIsPresent
|
|
set OemSetupFilePath = $(FileToCheck)
|
|
set NfError = 1
|
|
|
|
ifstr(i) $(STATUS) == YES
|
|
set NfError = 2
|
|
;
|
|
; Check that the INF represents the option we are looking for
|
|
;
|
|
shell $(OemSetupFilePath) Identify
|
|
ifstr(i) $($R0) == "STATUS_SUCCESSFUL"
|
|
ifstr(i) $($R1) == $(Option)
|
|
ForListDo $(!STF_BUSTYPELIST)
|
|
shell $(OemSetupFilePath) ReturnOptions $($0) $($)
|
|
ifstr(i) $($R0) == STATUS_SUCCESSFUL
|
|
set OemList = $($R1)
|
|
set OemTextList = $($R2)
|
|
goto asksingleselection
|
|
endif
|
|
EndForListDo
|
|
endif
|
|
endif
|
|
endif
|
|
;
|
|
; The file isn't in NT format; try the alternate name.
|
|
;
|
|
ifstr(i) $(InfName) == $(InfName1)
|
|
Set InfName = $(InfName2)
|
|
goto ask_inf_retry
|
|
endif
|
|
|
|
read-syms NonFatalError$(NfError)$($0)
|
|
shell "subroutn.inf" SetupMessage $($0) "NONFATAL" $(NonFatal)
|
|
goto ask_dodiskette
|
|
|
|
;
|
|
; Present the OEM options to the user. Let the user select. If
|
|
; the user selects to cancel, don't change anything, just return
|
|
;
|
|
|
|
asksingleselection = +
|
|
shell "" DoSingleOption $(OemList) $(OemTextList) $(OptDiskette) $(OptionalDlgText)
|
|
ifstr(i) $($R0) == STATUS_FAILED
|
|
set Status = STATUS_FAILED
|
|
goto finish_GetOEMOption
|
|
else-ifstr(i) $($R0) == STATUS_USERCANCEL
|
|
set Status = STATUS_USERCANCEL
|
|
goto finish_GetOEMOption
|
|
endif
|
|
|
|
set OptionChosen = $($R1)
|
|
set OptionChosenText = $($R2)
|
|
|
|
;
|
|
; Determine the file name to use to copy over. First see if the INF
|
|
; is a duplicate
|
|
;
|
|
|
|
set Duplicate = FALSE
|
|
ForListDo $($1)
|
|
ifstr(i) *($($), 2) == $(OemList)
|
|
set OemFileName = *($($), 1)
|
|
set Duplicate = TRUE
|
|
FlushInf $(OemFileName)
|
|
goto copyinf
|
|
endif
|
|
EndForListDo
|
|
|
|
;
|
|
; Not a duplicate, we need to copy it under a unique name.
|
|
;
|
|
|
|
set Num = 0
|
|
nextinf = +
|
|
ifint $(Num) < 99
|
|
set OemFileName = "oem"$(Abb)$(Num)".inf"
|
|
set FileToCheck = $(!STF_WINDOWSSYSPATH)"\"$(OemFileName)
|
|
install Install-SeeIfFileIsPresent
|
|
ifstr(i) $(STATUS) == "YES"
|
|
set-add Num = $(Num) 1
|
|
goto nextinf
|
|
else
|
|
goto copyinf
|
|
endif
|
|
endif
|
|
goto finish_GetOEMOption
|
|
|
|
copyinf = +
|
|
;
|
|
; copy the INF over to the windows system directory
|
|
;
|
|
set OemSrc = $(OemSetupFilePath)
|
|
set OemDst = $(!STF_WINDOWSSYSPATH)"\"$(OemFileName)
|
|
install Install-OemINF
|
|
|
|
|
|
;
|
|
; form the new oem option list
|
|
;
|
|
ifstr(i) $(Duplicate) == TRUE
|
|
else
|
|
set NewOemOptionList = >($(NewOemOptionList), {$(OemFileName), $(OemList), $(OemTextList)})
|
|
endif
|
|
set Status = STATUS_SUCCESSFUL
|
|
|
|
finish_GetOEMOption = +
|
|
FlushInf $(InfName)
|
|
Return $(Status) $(NewOemOptionList) $(OptionChosen) $(OptionChosenText) $(OptDisketteSrc)
|
|
|
|
;-----------------------------------------------------------------------
|
|
;
|
|
; ROUTINE: GetNewOEMMultiOption
|
|
;
|
|
; DESCRIPTION: This routine prompts the user for a new OEM file, presents
|
|
; the options supported and if the user chooses one of these
|
|
; copies over the INF to the windows system directory.
|
|
;
|
|
; INPUTS: $0: Language to use
|
|
; $1: OemOptionList
|
|
; $2: OptionTypeList; e.g., { NetService, NetTransport }
|
|
; $3: OptDisketteSource
|
|
; $4: (Optional) Dialog Text
|
|
;
|
|
; OUTPUTS: $R0: STATUS: STATUS_SUCCESSFUL |
|
|
; STATUS_USERCANCEL |
|
|
; STATUS_FAILED |
|
|
;
|
|
; $R1: NewOemOptionList
|
|
; $R2: OemOptionChosen
|
|
; $R3: OemOptionChosenText
|
|
; $R4: OEMINFSource
|
|
;
|
|
;------------------------------------------------------------------------
|
|
|
|
[GetNewOEMMultiOption]
|
|
|
|
Debug-Output $(STF_CONTEXTINFNAME)": GetNewOEMMultiOption called"
|
|
|
|
set Status = STATUS_FAILED
|
|
|
|
set OptionType = ""
|
|
set OptionTypeList = $($2)
|
|
set OptDisketteSrc = $($3)
|
|
set OptionalDlgText = $($4)
|
|
set InfName1 = "OEMSETUP.INF"
|
|
set InfName2 = "OEMSETNT.INF"
|
|
|
|
read-syms OptionDisketteMulti$($0)
|
|
|
|
Set TypeNames = ^(Options,0)
|
|
Set TypeAbbs = ^(Options,1)
|
|
|
|
set NewOemOptionList = $($1)
|
|
set OptionChosen = ""
|
|
set OptionChosenText = ""
|
|
|
|
;
|
|
; Prompt the user for the diskette containing the INF
|
|
;
|
|
|
|
m_ask_dodiskette = +
|
|
Debug-Output $(STF_CONTEXTINFNAME)": GetNewOEMMultiOption shelling DoDiskette"
|
|
|
|
;
|
|
; Reset the INF name to the standard default
|
|
;
|
|
set InfName = $(InfName1)
|
|
|
|
shell "" DoDiskette $($0) $(OptDiskette) $(OptDisketteSrc)
|
|
set Status = STATUS_FAILED
|
|
|
|
ifstr(i) $($R0) == STATUS_USERCANCEL
|
|
set Status = STATUS_USERCANCEL
|
|
goto m_finish_GetOEMOption
|
|
else-ifstr(i) $($R0) == STATUS_FAILED
|
|
goto m_finish_GetOEMOption
|
|
endif
|
|
|
|
set OptDisketteSrc = $($R1)
|
|
|
|
;
|
|
; Check that the Diskette contains an INF we are looking for
|
|
;
|
|
|
|
m_ask_inf_retry = +
|
|
FlushInf $(InfName)
|
|
LibraryProcedure FileToCheck, $(!LIBHANDLE), AppendBackSlash $(OptDisketteSrc)
|
|
set FileToCheck = $(FileToCheck)$(InfName)
|
|
install Install-SeeIfFileIsPresent
|
|
set OemSetupFilePath = $(FileToCheck)
|
|
set NfError = 1
|
|
|
|
ifstr(i) $(STATUS) == YES
|
|
set NfError = 2
|
|
;
|
|
; Check that the INF represents the option we are looking for
|
|
;
|
|
shell $(OemSetupFilePath) Identify
|
|
ifstr(i) $($R0) == "STATUS_SUCCESSFUL"
|
|
ifcontains(i) $($R1) in $(OptionTypeList)
|
|
Set OptionType = $($R1)
|
|
ForListDo $(!STF_BUSTYPELIST)
|
|
shell $(OemSetupFilePath) ReturnOptions $($0) $($)
|
|
ifstr(i) $($R0) == STATUS_SUCCESSFUL
|
|
set OemList = $($R1)
|
|
set OemTextList = $($R2)
|
|
goto m_asksingleselection
|
|
endif
|
|
EndForListDo
|
|
endif
|
|
endif
|
|
endif
|
|
;
|
|
; The file wasn't found or isn't in NT format; try the alternate name.
|
|
;
|
|
ifstr(i) $(InfName) == $(InfName1)
|
|
Set InfName = $(InfName2)
|
|
goto m_ask_inf_retry
|
|
endif
|
|
|
|
read-syms NonFatalError$(NfError)$($0)
|
|
shell "subroutn.inf" SetupMessage $($0) "NONFATAL" $(NonFatal)
|
|
goto m_ask_dodiskette
|
|
|
|
;
|
|
; Present the OEM options to the user. Let the user select. If
|
|
; the user selects to cancel, don't change anything, just return
|
|
;
|
|
|
|
m_asksingleselection = +
|
|
shell "" DoSingleOption $(OemList) $(OemTextList) $(OptDiskette) $(OptionalDlgText)
|
|
ifstr(i) $($R0) == STATUS_FAILED
|
|
set Status = STATUS_FAILED
|
|
goto m_finish_GetOEMOption
|
|
else-ifstr(i) $($R0) == STATUS_USERCANCEL
|
|
set Status = STATUS_USERCANCEL
|
|
goto m_finish_GetOEMOption
|
|
endif
|
|
|
|
set OptionChosen = $($R1)
|
|
set OptionChosenText = $($R2)
|
|
|
|
;
|
|
; Determine the file name to use to copy over. First see if the INF
|
|
; is a duplicate
|
|
;
|
|
|
|
set Duplicate = FALSE
|
|
ForListDo $($1)
|
|
ifstr(i) *($($), 2) == $(OemList)
|
|
set OemFileName = *($($), 1)
|
|
set Duplicate = TRUE
|
|
FlushInf $(OemFileName)
|
|
goto m_copyinf
|
|
endif
|
|
EndForListDo
|
|
|
|
;
|
|
; Not a duplicate, we need to copy it under a unique name.
|
|
;
|
|
|
|
set Num = 0
|
|
Set Abb = *($(TypeAbbs),~($(TypeNames),$(OptionType)))
|
|
|
|
m_nextinf = +
|
|
ifint $(Num) < 99
|
|
set OemFileName = "oem"$(Abb)$(Num)".inf"
|
|
Debug-Output "OTHER.INF: Checking winsyspath for "$(OemFileName)
|
|
|
|
set FileToCheck = $(!STF_WINDOWSSYSPATH)"\"$(OemFileName)
|
|
install Install-SeeIfFileIsPresent
|
|
ifstr(i) $(STATUS) == "YES"
|
|
set-add Num = $(Num) 1
|
|
goto m_nextinf
|
|
else
|
|
goto m_copyinf
|
|
endif
|
|
endif
|
|
goto m_finish_GetOEMOption
|
|
|
|
m_copyinf = +
|
|
;
|
|
; copy the INF over to the windows system directory
|
|
;
|
|
set OemSrc = $(OemSetupFilePath)
|
|
set OemDst = $(!STF_WINDOWSSYSPATH)"\"$(OemFileName)
|
|
install Install-OemINF
|
|
;
|
|
; form the new oem option list
|
|
;
|
|
ifstr(i) $(Duplicate) == TRUE
|
|
else
|
|
set NewOemOptionList = >($(NewOemOptionList), {$(OemFileName), $(OemList), $(OemTextList)})
|
|
endif
|
|
set Status = STATUS_SUCCESSFUL
|
|
|
|
m_finish_GetOEMOption = +
|
|
FlushInf $(InfName)
|
|
Return $(Status) $(NewOemOptionList) $(OptionChosen) $(OptionChosenText) $(OptDisketteSrc)
|
|
|
|
;-----------------------------------------------------------------------
|
|
;
|
|
; ROUTINE: DoDiskette
|
|
;
|
|
; DESCRIPTION: This routine prompts the OEM for the source of the OEM
|
|
; Diskette
|
|
;
|
|
; INPUTS: $0: Language
|
|
; $1: OemDiskette
|
|
; $2: OemDisketteSrc
|
|
;
|
|
; OUTPUTS: $R0: STATUS: STATUS_SUCCESSFUL |
|
|
; STATUS_USERCANCEL |
|
|
; STATUS_FAILED
|
|
;
|
|
; $R1: Diskette Src
|
|
;
|
|
;------------------------------------------------------------------------
|
|
|
|
|
|
[DoDiskette]
|
|
;
|
|
;
|
|
set Status = STATUS_FAILED
|
|
set OemDiskette = $($1)
|
|
set OemDisketteSrc = $($2)
|
|
|
|
Debug-Output $(STF_CONTEXTINFNAME)": DoDiskette called"
|
|
|
|
read-syms DisketteDlg$($0)
|
|
ui start "Diskette"
|
|
ifstr(i) $(DLGEVENT) == "CONTINUE"
|
|
set OemDisketteSrc = $(EditTextOut)
|
|
ui pop 1
|
|
set Status = STATUS_SUCCESSFUL
|
|
goto finish_dodiskette
|
|
else-ifstr(i) $(DLGEVENT) == "BACK"
|
|
ui pop 1
|
|
set Status = STATUS_USERCANCEL
|
|
goto finish_dodiskette
|
|
else
|
|
ui pop 1
|
|
goto finish_dodiskette
|
|
endif
|
|
|
|
finish_dodiskette = +
|
|
Return $(Status) $(OemDisketteSrc)
|
|
|
|
;-----------------------------------------------------------------------
|
|
;
|
|
; ROUTINE: DoSingleOption
|
|
;
|
|
; DESCRIPTION: This routine presents the OEM Options to the user to
|
|
; get a selectiom
|
|
;
|
|
; INPUTS: $0: OptionList
|
|
; $1: OptionTextList
|
|
; $2: OptionTypeText
|
|
; $3: (Optional) dialog text
|
|
;
|
|
; OUTPUTS: $R0: STATUS: STATUS_SUCCESSFUL |
|
|
; STATUS_USERCANCEL |
|
|
; STATUS_FAILED
|
|
;
|
|
; $R1: OptionChosen
|
|
; $R2: OptionChosenText
|
|
;
|
|
;------------------------------------------------------------------------
|
|
|
|
|
|
[DoSingleOption]
|
|
|
|
set Status = STATUS_FAILED
|
|
set OemOptionChosen = ""
|
|
set OemOptionChosenText = ""
|
|
set OemOptionList = $($0)
|
|
set OemOptionTextList = $($1)
|
|
set OemOptionTypeText = $($2)
|
|
|
|
read-syms OemSingleOptionDlg$(!STF_LANGUAGE)
|
|
ifstr(i) $($3) != ""
|
|
set DlgText = $($3)
|
|
endif
|
|
|
|
ui start "Diskette"
|
|
ifstr(i) $(DLGEVENT) == "CONTINUE"
|
|
|
|
ui pop 1
|
|
ifstr(i) $(ListItemsOut) == ""
|
|
set Status = STATUS_USERCANCEL
|
|
else
|
|
set OemOptionChosenText = $(ListItemsOut)
|
|
set OemOptionChosen = *($($0), ~($(ListItemsIn), $(ListItemsOut)))
|
|
set Status = STATUS_SUCCESSFUL
|
|
endif
|
|
|
|
goto finish_dosingleoption
|
|
|
|
else-ifstr(i) $(DLGEVENT) == "BACK"
|
|
ui pop 1
|
|
set Status = STATUS_USERCANCEL
|
|
goto finish_dosingleoption
|
|
else
|
|
ui pop 1
|
|
set Status = STATUS_FAILED
|
|
goto finish_dosingleoption
|
|
|
|
endif
|
|
|
|
finish_dosingleoption = +
|
|
Return $(Status) $(OemOptionChosen) $(OemOptionChosenText)
|
|
|
|
|
|
;-----------------------------------------------------------------------
|
|
;
|
|
; ROUTINE: GetOptionsFromRegistry
|
|
;
|
|
; DESCRIPTION: Extract previously cached INF file option information
|
|
; from the Registry.
|
|
;
|
|
;
|
|
; INPUTS: $0: OptionType
|
|
; $1: OptionFileName
|
|
;
|
|
; OUTPUTS: $R0: STATUS: STATUS_SUCCESSFUL |
|
|
; STATUS_FAILED
|
|
;
|
|
; $R1: OptionList
|
|
; $R2: OptionTextList
|
|
;
|
|
; COMMENTARY:
|
|
; The Registry information was stored like this:
|
|
;
|
|
; HKEY_LOCAL_MACHINE\System\Setup\InfOptions\<filename>
|
|
;
|
|
; The Registry information is stored like this:
|
|
;
|
|
; HKEY_LOCAL_MACHINE\Software\Microsoft\Ncpa\InfOptions\<filename>
|
|
;
|
|
; DateLow = REG_DWORD <lsw of numeric timestamp of file>
|
|
;
|
|
; # Keys named <optionType>.<bus ID>
|
|
;
|
|
; NetDriver.ISA
|
|
; OptionList = REG_MULTI_SZ <list of options>
|
|
; OptionTextList = REG_MULTI_SZ <list of text options>
|
|
;
|
|
;------------------------------------------------------------------------
|
|
[GetOptionsFromRegistry]
|
|
Set InfType = $($0)
|
|
Set InfFullName = $($1)
|
|
Set Status = STATUS_FAILED
|
|
Set OptionList = {}
|
|
Set OptionTextList = {}
|
|
Set KeyInf = ""
|
|
Set KeyType = ""
|
|
Set RegLastError = $(!REG_ERROR_SUCCESS)
|
|
;
|
|
; See if there's a bus type defined. If not,don't even try.
|
|
;
|
|
Ifstr(i) $(!STF_BUSTYPE) == ""
|
|
goto finish_getregoptions
|
|
Endif
|
|
;
|
|
; Extract the file name from the tail of the full path\name
|
|
;
|
|
Split-String $(InfFullName) "\" NameInfo
|
|
QueryListSize NameInfoListSize $(NameInfo)
|
|
Set InfName = *($(NameInfo),$(NameInfoListSize))
|
|
|
|
Set KeyName = "Software\Microsoft\Ncpa\InfOptions\"$(InfName)
|
|
OpenRegKey $(!REG_H_LOCAL) "" $(KeyName) $(!REG_KEY_READ) KeyInf
|
|
Ifint $(RegLastError) != $(!REG_ERROR_SUCCESS)
|
|
goto finish_getregoptions
|
|
Endif
|
|
|
|
;
|
|
; Key exists. Validate the file date/time stamp.
|
|
;
|
|
Set FileDateTimeName = $(InfName)
|
|
Detect DetectFileTime
|
|
Set TimeLow = *($(FileDateTime),1)
|
|
|
|
Ifint $(TimeLow) == 0
|
|
goto finish_getregoptions
|
|
Endif
|
|
|
|
GetRegValue $(KeyInf) DateLow ValueRegTimeLow
|
|
Ifint $(RegLastError) != $(!REG_ERROR_SUCCESS)
|
|
goto finish_getregoptions
|
|
Endif
|
|
|
|
Set RegTimeLow = *($(ValueRegTimeLow),4)
|
|
|
|
Ifint $(TimeLow) != $(RegTimeLow)
|
|
goto finish_getregoptions
|
|
Endif
|
|
|
|
;
|
|
; Date time stamp matches. See if there's info
|
|
; for the given option type on the current bus
|
|
;
|
|
ForListDo $(!STF_BUSTYPELIST)
|
|
Set TypeKeyName = $(InfType)"."$($)
|
|
OpenRegKey $(KeyInf) "" $(TypeKeyName) $(!REG_KEY_READ) KeyType
|
|
ifint $(RegLastError) == $(!REG_ERROR_SUCCESS )
|
|
goto findit
|
|
endif
|
|
EndForListDo
|
|
Ifint $(RegLastError) != $(!REG_ERROR_SUCCESS)
|
|
;
|
|
; No option data for this type.
|
|
; Not supported by this INF.
|
|
;
|
|
Set Status = STATUS_SUCCESSFUL
|
|
goto finish_getregoptions
|
|
Endif
|
|
|
|
findit = +
|
|
;
|
|
; Fetch the option list and the option text list.
|
|
;
|
|
GetRegValue $(KeyType) OptionList ValueOptionList
|
|
Ifint $(RegLastError) != $(!REG_ERROR_SUCCESS)
|
|
goto finish_getregoptions
|
|
Endif
|
|
Set OptionList = *($(ValueOptionList),4)
|
|
|
|
GetRegValue $(KeyType) OptionTextList ValueOptionTextList
|
|
Ifint $(RegLastError) != $(!REG_ERROR_SUCCESS)
|
|
goto finish_getregoptions
|
|
Endif
|
|
Set OptionTextList = *($(ValueOptionTextList),4)
|
|
|
|
Set Status = STATUS_SUCCESSFUL
|
|
|
|
finish_getregoptions =+
|
|
|
|
Ifstr(i) $(Status) != STATUS_SUCCESSFUL
|
|
Set OptionList = {}
|
|
Set OptionTextList = {}
|
|
Endif
|
|
|
|
Ifstr(i) $(KeyType) != ""
|
|
CloseRegKey $(KeyType)
|
|
Endif
|
|
Ifstr(i) $(KeyInf) != ""
|
|
CloseRegKey $(KeyInf)
|
|
Endif
|
|
|
|
return $(Status) $(OptionList) $(OptionTextList)
|
|
|
|
;-----------------------------------------------------------------------
|
|
;
|
|
; ROUTINE: SetOptionsIntoRegistry
|
|
;
|
|
; DESCRIPTION: Update cached INF file option information into
|
|
; the Registry.
|
|
;
|
|
;
|
|
; INPUTS: $0: OptionType
|
|
; $1: OptionFileName
|
|
; $2: OptionList
|
|
; $3: OptionTextList
|
|
;
|
|
; OUTPUTS: $R0: STATUS: STATUS_SUCCESSFUL |
|
|
; STATUS_USERCANCEL |
|
|
; STATUS_FAILED
|
|
;
|
|
;
|
|
;------------------------------------------------------------------------
|
|
[SetOptionsIntoRegistry]
|
|
Debug-Output "OTHER.INF: SetOptionsIntoRegistry - Entry "$($0)", "$($1)", "$($2)", "$($3)
|
|
Set OptionType = $($0)
|
|
Set InfFullName = $($1)
|
|
Set OptionList = $($2)
|
|
Set OptionTextList = $($3)
|
|
Set MaskAllAccess = 33554432
|
|
Set NoTitle = 0
|
|
Set RegLastError = $(!REG_ERROR_SUCCESS)
|
|
Set Status = STATUS_FAILED
|
|
Set KeyInf = ""
|
|
;
|
|
; See if there's a bus type defined. If not,don't even try.
|
|
;
|
|
Ifstr(i) $(!STF_BUSTYPE) == ""
|
|
goto finish_setregoptions
|
|
Endif
|
|
;
|
|
; Extract the file name from the tail of the full path\name
|
|
;
|
|
Split-String $(InfFullName) "\" NameInfo
|
|
QueryListSize NameInfoListSize $(NameInfo)
|
|
Set InfName = *($(NameInfo),$(NameInfoListSize))
|
|
|
|
Set KeyInfName = "SOFTWARE\Microsoft\Ncpa\InfOptions\"$(InfName)
|
|
Set KeyOptName = $(OptionType)"."$(!STF_BUSTYPE)
|
|
;
|
|
; Get the time stamp for this file; check for failure.
|
|
;
|
|
Set FileDateTimeName = $(InfName)
|
|
Detect DetectFileTime
|
|
Set TimeLsw = *($(FileDateTime),1)
|
|
Ifint $(TimeLsw) == 0
|
|
goto finish_setregoptions
|
|
Endif
|
|
;
|
|
; Create or open the key for this INF.
|
|
;
|
|
Set KeyInfo = {$(KeyInfName),$(NoTitle),""}
|
|
OpenRegKey $(!REG_H_LOCAL) "" $(KeyInfName) $(MaskAllAccess) KeyInf
|
|
ifstr(i) $(KeyInf) == ""
|
|
CreateRegKey $(!REG_H_LOCAL) $(KeyInfo) "" $(MaskAllAccess) "" KeyInf
|
|
Ifint $(RegLastError) != $(!REG_ERROR_SUCCESS)
|
|
Debug-Output "OTHER.INF: SetOptionsIntoRegistry - Reg Error"$(KeyInfo)
|
|
goto finish_setregoptions
|
|
Endif
|
|
Endif
|
|
;
|
|
; Create or open the key for this type
|
|
;
|
|
Set KeyInfo = {$(KeyOptName),$(NoTitle),""}
|
|
OpenRegKey $(KeyInf) "" $(KeyOptName) $(MaskAllAccess) KeyType
|
|
ifstr(i) $(KeyType) == ""
|
|
CreateRegKey $(KeyInf) $(KeyInfo) "" $(MaskAllAccess) "" KeyType
|
|
Ifint $(RegLastError) != $(!REG_ERROR_SUCCESS)
|
|
Debug-Output "OTHER.INF: SetOptionsIntoRegistry - Reg Error"$(KeyInfo)
|
|
goto finish_setregoptions
|
|
Endif
|
|
Endif
|
|
|
|
;
|
|
; Write the values. First the time stamp (under the INF key),
|
|
; then the lists (under the type.bustype sub-key).
|
|
;
|
|
Set ValueInfo = {DateLow, $(NoTitle), $(!REG_VT_DWORD), $(TimeLsw)}
|
|
SetRegValue $(KeyInf) $(ValueInfo)
|
|
Ifint $(RegLastError) != $(!REG_ERROR_SUCCESS)
|
|
goto finish_setregoptions
|
|
Endif
|
|
|
|
Set ValueInfo = {OptionList, $(NoTitle), $(!REG_VT_MULTI_SZ), $(OptionList)}
|
|
SetRegValue $(KeyType) $(ValueInfo)
|
|
Ifint $(RegLastError) != $(!REG_ERROR_SUCCESS)
|
|
goto finish_setregoptions
|
|
Endif
|
|
|
|
Set ValueInfo = {OptionTextList, $(NoTitle), $(!REG_VT_MULTI_SZ), $(OptionTextList)}
|
|
SetRegValue $(KeyType) $(ValueInfo)
|
|
Ifint $(RegLastError) != $(!REG_ERROR_SUCCESS)
|
|
goto finish_setregoptions
|
|
Endif
|
|
|
|
Set Status = STATUS_SUCCESSFUL
|
|
|
|
finish_setregoptions =+
|
|
|
|
Ifstr(i) $(KeyType) != ""
|
|
CloseRegKey $(KeyType)
|
|
;
|
|
; If the update operation failed, nuke the type.bustype key and values
|
|
;
|
|
Ifstr(i) $(Status) != STATUS_SUCCESSFUL
|
|
DeleteRegTree $(KeyOptName)
|
|
Endif
|
|
Endif
|
|
Ifstr(i) $(KeyInf) != ""
|
|
CloseRegKey $(KeyInf)
|
|
Endif
|
|
Debug-Output "OTHER.INF: SetOptionsIntoRegistry - Exit "$(Status)
|
|
return $(Status)
|
|
|
|
|
|
[Install-SeeIfFileIsPresent]
|
|
LibraryProcedure STATUS,$(!LIBHANDLE), CheckFileExistance $(FileToCheck)
|
|
exit
|
|
|
|
|
|
|
|
|
|
[Install-OemINF]
|
|
LibraryProcedure STATUS,$(!NCPA_HANDLE), CopySingleFile $(!STF_HWND) $(OemSrc) $(OemDst)
|
|
exit
|
|
|