static void SB_Reset(void)
{
int i;
for(i=0;i<256;i++)
DSP_Command[i]=0;
/* Set Time Constant */
DSP_Command[0x40]=1;
/* Generate IRQ */
DSP_Command[0xF2]=0;
/* DMA DAC 8-bits */
DSP_Command[0x14]=2;
/* Generic DAC/ADC DMA (16-bit, 8-bit) */
for(i=0xB0;i<=0xCF;i++)
DSP_Command[i]=3;
/* DSP Identification */
DSP_Command[0xE0]=1;
/* Clear command and input buffer */
command = -1;
InSize = 0;
/* Put a garbage value in the output buffer */
OutSize = 1;
if (SB_Init())
/* All right, let's put the magic value for autodetection */
DSP_OutBuffer[0] = 0xaa;
else
/* Something is wrong, put 0 to failed autodetection */
DSP_OutBuffer[0] = 0x00;
}
static Macro* NewMacro (const StrBuf* Name, unsigned char Style)
/* Generate a new macro entry, initialize and return it */
{
/* Allocate memory */
Macro* M = xmalloc (sizeof (Macro));
/* Initialize the macro struct */
InitHashNode (&M->Node);
M->LocalCount = 0;
M->Locals = 0;
M->ParamCount = 0;
M->Params = 0;
M->TokCount = 0;
M->TokRoot = 0;
M->TokLast = 0;
SB_Init (&M->Name);
SB_Copy (&M->Name, Name);
M->Expansions = 0;
M->Style = Style;
M->Incomplete = 1;
/* Insert the macro into the hash table */
HT_Insert (&MacroTab, &M->Node);
/* Return the new macro struct */
return M;
}
static MacroExp* InitMacroExp (MacroExp* E, Macro* M)
/* Initialize a MacroExp structure */
{
InitCollection (&E->ActualArgs);
SB_Init (&E->Replacement);
E->M = M;
return E;
}
int SendBreak(SOCKET s, const char * file, int line)
{
SocketBuf sb;
SB_Init(&sb, s);
SB_Print(&sb, "BR\n%s\n%d\n\n", file, line);
SB_Add(&sb, "", 1); //Add the End-of-flow(EOF)
return SB_Send(&sb);
}
int SendOK(SOCKET s, Writer writer, void * writerData)
{
SocketBuf sb;
int rc = 0;
SB_Init(&sb, s);
SB_Add(&sb, "OK\n", sizeof("OK\n") - 1);
if (writer)
while ((rc = writer(writerData, &sb)) == 1);
SB_Add(&sb, "\n", sizeof("\n")); //Include the End-of-flow(EOF)
SB_Send(&sb);
return (rc == 0 && !sb.ioerr) ? 0 : (rc < 0 ? rc : -1);
}
int SendErr(SOCKET s, const char * fmt, ...)
{
SocketBuf sb;
va_list ap;
SB_Init(&sb, s);
SB_Add(&sb, "ER\n", sizeof("ER\n") - 1);
va_start(ap, fmt);
SB_VPrint(&sb, fmt, ap);
va_end(ap);
SB_Add(&sb, "\n", sizeof("\n")); //Include the End-of-flow(EOF)
return SB_Send(&sb);
}
static IdDesc* NewIdDesc (const StrBuf* Id)
/* Create a new IdDesc, initialize and return it */
{
/* Allocate memory */
IdDesc* ID = xmalloc (sizeof (IdDesc));
/* Initialize the struct */
ID->Next = 0;
SB_Init (&ID->Id);
SB_Copy (&ID->Id, Id);
/* Return the new struct */
return ID;
}
static Literal* NewLiteral (const void* Buf, unsigned Len)
/* Create a new literal and return it */
{
/* Allocate memory */
Literal* L = xmalloc (sizeof (*L));
/* Initialize the fields */
L->Label = GetLocalLabel ();
L->RefCount = 0;
L->Output = 0;
SB_Init (&L->Data);
SB_AppendBuf (&L->Data, Buf, Len);
/* Return the new literal */
return L;
}
int NewInputFile (const char* Name)
/* Open a new input file. Returns true if the file could be successfully opened
** and false otherwise.
*/
{
int RetCode = 0; /* Return code. Assume an error. */
char* PathName = 0;
FILE* F;
struct stat Buf;
StrBuf NameBuf; /* No need to initialize */
StrBuf Path = AUTO_STRBUF_INITIALIZER;
unsigned FileIdx;
CharSource* S;
/* If this is the main file, just try to open it. If it's an include file,
** search for it using the include path list.
*/
if (FCount == 0) {
/* Main file */
F = fopen (Name, "r");
if (F == 0) {
Fatal ("Cannot open input file '%s': %s", Name, strerror (errno));
}
} else {
/* We are on include level. Search for the file in the include
** directories.
*/
PathName = SearchFile (IncSearchPath, Name);
if (PathName == 0 || (F = fopen (PathName, "r")) == 0) {
/* Not found or cannot open, print an error and bail out */
Error ("Cannot open include file '%s': %s", Name, strerror (errno));
goto ExitPoint;
}
/* Use the path name from now on */
Name = PathName;
}
/* Stat the file and remember the values. There's a race condition here,
** since we cannot use fileno() (non-standard identifier in standard
** header file), and therefore not fstat. When using stat with the
** file name, there's a risk that the file was deleted and recreated
** while it was open. Since mtime and size are only used to check
** if a file has changed in the debugger, we will ignore this problem
** here.
*/
if (FileStat (Name, &Buf) != 0) {
Fatal ("Cannot stat input file '%s': %s", Name, strerror (errno));
}
/* Add the file to the input file table and remember the index */
FileIdx = AddFile (SB_InitFromString (&NameBuf, Name),
(FCount == 0)? FT_MAIN : FT_INCLUDE,
Buf.st_size, (unsigned long) Buf.st_mtime);
/* Create a new input source variable and initialize it */
S = xmalloc (sizeof (*S));
S->Func = &IFFunc;
S->V.File.F = F;
S->V.File.Pos.Line = 0;
S->V.File.Pos.Col = 0;
S->V.File.Pos.Name = FileIdx;
SB_Init (&S->V.File.Line);
/* Push the path for this file onto the include search lists */
SB_CopyBuf (&Path, Name, FindName (Name) - Name);
SB_Terminate (&Path);
S->V.File.IncSearchPath = PushSearchPath (IncSearchPath, SB_GetConstBuf (&Path));
S->V.File.BinSearchPath = PushSearchPath (BinSearchPath, SB_GetConstBuf (&Path));
SB_Done (&Path);
/* Count active input files */
++FCount;
/* Use this input source */
UseCharSource (S);
/* File successfully opened */
RetCode = 1;
ExitPoint:
/* Free an allocated name buffer */
xfree (PathName);
/* Return the success code */
return RetCode;
}
void D_DoomMain(void)
{
GameMission_t gamemission;
int p;
I_AtExit(D_HexenQuitMessage, false);
startepisode = 1;
autostart = false;
startskill = sk_medium;
startmap = 1;
gamemode = commercial;
I_PrintBanner(PACKAGE_STRING);
// Initialize subsystems
ST_Message("V_Init: allocate screens.\n");
V_Init();
// Load defaults before initing other systems
ST_Message("M_LoadDefaults: Load system defaults.\n");
D_BindVariables();
#ifdef _WIN32
//!
// @platform windows
// @vanilla
//
// Save configuration data and savegames in c:\hexndata,
// allowing play from CD.
//
cdrom = M_ParmExists("-cdrom");
#endif
if (cdrom)
{
M_SetConfigDir("c:\\hexndata\\");
}
else
{
M_SetConfigDir(NULL);
}
D_SetDefaultSavePath();
M_SetConfigFilenames("hexen.cfg", PROGRAM_PREFIX "hexen.cfg");
M_LoadDefaults();
I_AtExit(M_SaveDefaults, false);
// Now that the savedir is loaded from .CFG, make sure it exists
CreateSavePath();
ST_Message("Z_Init: Init zone memory allocation daemon.\n");
Z_Init();
// haleyjd: removed WATCOMC
ST_Message("W_Init: Init WADfiles.\n");
iwadfile = D_FindIWAD(IWAD_MASK_HEXEN, &gamemission);
if (iwadfile == NULL)
{
I_Error("Game mode indeterminate. No IWAD was found. Try specifying\n"
"one with the '-iwad' command line parameter.");
}
D_AddFile(iwadfile);
W_CheckCorrectIWAD(hexen);
D_IdentifyVersion();
D_SetGameDescription();
AdjustForMacIWAD();
HandleArgs();
I_PrintStartupBanner(gamedescription);
ST_Message("MN_Init: Init menu system.\n");
MN_Init();
ST_Message("CT_Init: Init chat mode data.\n");
CT_Init();
InitMapMusicInfo(); // Init music fields in mapinfo
ST_Message("S_InitScript\n");
S_InitScript();
ST_Message("SN_InitSequenceScript: Registering sound sequences.\n");
SN_InitSequenceScript();
ST_Message("I_Init: Setting up machine state.\n");
I_CheckIsScreensaver();
I_InitTimer();
I_InitJoystick();
I_InitSound(false);
I_InitMusic();
#ifdef FEATURE_MULTIPLAYER
ST_Message("NET_Init: Init networking subsystem.\n");
NET_Init();
#endif
D_ConnectNetGame();
S_Init();
S_Start();
ST_Message("ST_Init: Init startup screen.\n");
ST_Init();
// Show version message now, so it's visible during R_Init()
ST_Message("R_Init: Init Hexen refresh daemon");
R_Init();
ST_Message("\n");
//if (M_CheckParm("-net"))
// ST_NetProgress(); // Console player found
ST_Message("P_Init: Init Playloop state.\n");
P_Init();
// Check for command line warping. Follows P_Init() because the
// MAPINFO.TXT script must be already processed.
WarpCheck();
ST_Message("D_CheckNetGame: Checking network game status.\n");
D_CheckNetGame();
ST_Message("SB_Init: Loading patches.\n");
SB_Init();
ST_Done();
if (autostart)
{
ST_Message("Warp to Map %d (\"%s\":%d), Skill %d\n",
WarpMap, P_GetMapName(startmap), startmap, startskill + 1);
}
CheckRecordFrom();
p = M_CheckParm("-record");
if (p && p < myargc - 1)
{
G_RecordDemo(startskill, 1, startepisode, startmap, myargv[p + 1]);
H2_GameLoop(); // Never returns
}
p = M_CheckParmWithArgs("-playdemo", 1);
if (p)
{
singledemo = true; // Quit after one demo
G_DeferedPlayDemo(demolumpname);
H2_GameLoop(); // Never returns
}
p = M_CheckParmWithArgs("-timedemo", 1);
if (p)
{
G_TimeDemo(demolumpname);
H2_GameLoop(); // Never returns
}
//!
// @arg <s>
// @vanilla
//
// Load the game in savegame slot s.
//
p = M_CheckParmWithArgs("-loadgame", 1);
if (p)
{
G_LoadGame(atoi(myargv[p + 1]));
}
if (gameaction != ga_loadgame)
{
UpdateState |= I_FULLSCRN;
BorderNeedRefresh = true;
if (autostart || netgame)
{
G_StartNewInit();
G_InitNew(startskill, startepisode, startmap);
}
else
{
H2_StartTitle();
}
}
H2_GameLoop(); // Never returns
}
static void LineMarkerOrComment ()
/* Handle a line beginning with '#'. Possible interpretations are:
** - #line <lineno> ["<filename>"] (C preprocessor input)
** - # <lineno> "<filename>" [<flag>]... (gcc preprocessor output)
** - #<comment>
*/
{
unsigned long LineNo = 0;
int LineDirective = 0;
StrBuf SrcNameBuf = AUTO_STRBUF_INITIALIZER;
/* Skip the first "# " */
NextChar ();
SkipBlanks (1);
/* Check "line" */
if (C == 'l') {
char MaybeLine [6];
unsigned I;
for (I = 0; I < sizeof MaybeLine - 1 && C != EOF && IsAlNum (C); ++I) {
MaybeLine [I] = C;
NextChar ();
}
MaybeLine [I] = 0;
if (strcmp (MaybeLine, "line") != 0) {
goto NotMarker;
}
LineDirective = 1;
SkipBlanks (1);
}
/* Get line number */
if (C == EOF || !IsDigit (C)) {
goto NotMarker;
}
LineNo = GetDecimalToken ();
SkipBlanks (1);
/* Get the source file name */
if (C != '\"') {
/* The source file name is missing */
if (LineDirective && C == '\n') {
/* got #line <lineno> */
NextChar ();
InputLine = LineNo;
goto Last;
} else {
goto NotMarker;
}
}
NextChar ();
while (C != EOF && C != '\n' && C != '\"') {
char DecodeBuf [2];
unsigned I = 0;
if (GetEncodedChar (DecodeBuf, &I, sizeof DecodeBuf) < 0) {
goto BadMarker;
}
SB_AppendBuf (&SrcNameBuf, DecodeBuf, I);
}
if (C != '\"') {
goto BadMarker;
}
NextChar ();
/* Ignore until the end of line */
while (C != EOF && C != '\n') {
NextChar ();
}
/* Accepted a line marker */
SB_Terminate (&SrcNameBuf);
xfree (InputSrcName);
InputSrcName = SB_GetBuf (&SrcNameBuf);
SB_Init (&SrcNameBuf);
InputLine = (unsigned)LineNo;
NextChar ();
goto Last;
BadMarker:
InfoWarning ("Bad line marker");
NotMarker:
while (C != EOF && C != '\n') {
NextChar ();
}
NextChar ();
Last:
SB_Done (&SrcNameBuf);
}
// *****************************************************************************
// InitialiseHW
// Setup the processor
// *****************************************************************************
void InitialiseHW ( void )
{
// If running on Rev A2 silicon, turn the LDO voltage up to 2.75V. This is
// a workaround to allow the PLL to operate reliably.
//
if(REVISION_IS_A2)
{
SysCtlLDOSet(SYSCTL_LDO_2_75V);
}
// 50 MHz
SysCtlClockSet(SYSCTL_SYSDIV_4 | SYSCTL_USE_PLL | SYSCTL_OSC_MAIN | SYSCTL_XTAL_8MHZ);
// Enable Peripherals
SysCtlPeripheralEnable(SYSCTL_PERIPH_ETH);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOA);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOB);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOC);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOD);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOE);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOF);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOG);
SysCtlPeripheralEnable(SYSCTL_PERIPH_GPIOH);
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART0);
SysCtlPeripheralEnable(SYSCTL_PERIPH_UART1);
// Set interrupt priority levels
IntPrioritySet(INT_ETH, 0x20);
IntPrioritySet(FAULT_SYSTICK, 0x40);
//
// Enable the peripherals that should continue to run when the processor
// is sleeping.
//
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOA);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOB);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOC);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOD);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOE);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOF);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOG);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_GPIOH);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_UART0);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_UART1);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_ETH);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_TIMER0);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_TIMER1);
SysCtlPeripheralSleepEnable(SYSCTL_PERIPH_TIMER2);
//
// Enable peripheral clock gating. Note that this is required in order to
// measure the the processor usage.
//
SysCtlPeripheralClockGating(true);
// Grab the Config from Flash
SysConfigInit();
AdcInit();
pwmInit();
RelayInit();
//usrand(0x23482937);
// Note (From the DriverLib) :
// It takes five clock cycles after the write to enable a peripheral
// before the the peripheral is actually enabled. During this time, attempts
// to access the peripheral result in a bus fault. Care should be taken
// to ensure that the peripheral is not accessed during this brief time
// period.
#ifdef SERIAL_ENABLED
Serial_Init();
#endif
#ifdef UPNP_ENABLED
UPnPInit();
#endif
Ethernet_Init();
#ifdef LOGIC_ENABLED
LogicStartStop(true);
#endif
#ifdef SOLDERBRIDGES_ENABLED
SB_Init();
ExtGpio_Init();
SolderBridge_StartScan();
ExtGpio_Scan();
#endif
#ifdef SPLASHPIXEL_ENABLED
SP_Init();
#endif
// Set up the GPIO as specified by the user
UserGpioInit();
// Most, if not all M3's have a SysTick which you can use for scheduling your code
SysTickPeriodSet(SysCtlClockGet() / SYSTICKHZ);
SysTickEnable();
SysTickIntEnable();
}
