int
main (int argc, char **argv)
{
struct commandline cmd;
(void) memset ((char *) &cmd, 0, sizeof (struct commandline));
clear_args ();
if (!parseargs (argc, argv, &cmd) || !cmd.infile)
usage ();
if (cmd.cflag || cmd.hflag || cmd.tflag)
checkfiles (cmd.infile, cmd.outfile);
else
checkfiles (cmd.infile, NULL);
if (cmd.cflag) {
c_output (cmd.infile, "-DRPC_XDR", DONT_EXTEND, cmd.outfile);
}
else if (cmd.hflag) {
h_output (cmd.infile, "-DRPC_HDR", DONT_EXTEND, cmd.outfile);
}
else if (cmd.tflag) {
t_output (cmd.infile, "-DRPC_TBL", DONT_EXTEND, cmd.outfile);
}
else {
/* the rescans are required, since cpp may effect input */
c_output (cmd.infile, "-DRPC_XDR", EXTEND, "_xdr.c");
reinitialize ();
h_output (cmd.infile, "-DRPC_HDR", EXTEND, ".h");
reinitialize ();
t_output (cmd.infile, "-DRPC_TBL", EXTEND, "_tbl.c");
}
#ifdef __MSDOS__
if (dos_cppfile != NULL) {
(void) fclose (fin);
(void) unlink (dos_cppfile);
}
#endif
exit (nonfatalerrors);
/* NOTREACHED */
}
/*
* Name: show_vertical_separator
* Purpose: To separate vertical screens
* Date: June 5, 1991
* Passed: window: pointer to current window
*/
void show_vertical_separator( WINDOW *window )
{
int i;
int line;
int col;
line = window->top_line - 1;
col = window->end_col + 1;
if (col < g_display.ncols - 1) {
i = window->bottom_line - line;
assert( i <= g_display.nlines );
while (i-- >= 0)
c_output( VERTICAL_CHAR, col, line++, g_display.head_color );
}
}
int
main(int argc, const char **argv)
{
struct commandline cmd;
memset(&cmd, 0, sizeof (struct commandline));
clear_args();
if (!parseargs(argc, argv, &cmd))
usage();
/*
* Only the client and server side stubs are likely to be customized,
* so in that case only, check if the outfile exists, and if so,
* print an error message and exit.
*/
if (cmd.Ssflag || cmd.Scflag || cmd.makefileflag)
checkfiles(cmd.infile, cmd.outfile);
else
checkfiles(cmd.infile, NULL);
if (cmd.cflag) {
c_output(cmd.infile, "-DRPC_XDR", DONT_EXTEND, cmd.outfile);
} else if (cmd.hflag) {
h_output(cmd.infile, "-DRPC_HDR", DONT_EXTEND, cmd.outfile,
cmd.hflag);
} else if (cmd.lflag) {
l_output(cmd.infile, "-DRPC_CLNT", DONT_EXTEND, cmd.outfile);
} else if (cmd.sflag || cmd.mflag || (cmd.nflag)) {
s_output(argc, argv, cmd.infile, "-DRPC_SVC", DONT_EXTEND,
cmd.outfile, cmd.mflag, cmd.nflag);
} else if (cmd.tflag) {
t_output(cmd.infile, "-DRPC_TBL", DONT_EXTEND, cmd.outfile);
} else if (cmd.Ssflag) {
svc_output(cmd.infile, "-DRPC_SERVER", DONT_EXTEND,
cmd.outfile);
} else if (cmd.Scflag) {
clnt_output(cmd.infile, "-DRPC_CLIENT", DONT_EXTEND,
cmd.outfile);
} else if (cmd.makefileflag) {
mkfile_output(&cmd);
} else {
/* the rescans are required, since cpp may effect input */
c_output(cmd.infile, "-DRPC_XDR", EXTEND, "_xdr.c");
reinitialize();
h_output(cmd.infile, "-DRPC_HDR", EXTEND, ".h", cmd.hflag);
reinitialize();
l_output(cmd.infile, "-DRPC_CLNT", EXTEND, "_clnt.c");
reinitialize();
if (inetdflag || !tirpcflag)
s_output(allc, allv, cmd.infile, "-DRPC_SVC", EXTEND,
"_svc.c", cmd.mflag, cmd.nflag);
else
s_output(allnc, allnv, cmd.infile, "-DRPC_SVC",
EXTEND, "_svc.c", cmd.mflag, cmd.nflag);
if (tblflag) {
reinitialize();
t_output(cmd.infile, "-DRPC_TBL", EXTEND, "_tbl.i");
}
if (allfiles) {
reinitialize();
svc_output(cmd.infile, "-DRPC_SERVER", EXTEND,
"_server.c");
reinitialize();
clnt_output(cmd.infile, "-DRPC_CLIENT", EXTEND,
"_client.c");
}
if (allfiles || (cmd.makefileflag == 1)){
reinitialize();
mkfile_output(&cmd);
}
}
exit(nonfatalerrors);
/* NOTREACHED */
}
int
main(int argc, char *argv[])
{
struct commandline cmd;
#ifdef AFS_NT40_ENV
/* initialize CPP with the correct pre-processor for Windows */
CPP = getenv("RXGEN_CPPCMD");
if (!CPP)
CPP = "cl /EP /C /nologo";
#endif /* AFS_NT40_ENV */
#ifdef AFS_AIX32_ENV
/*
* The following signal action for AIX is necessary so that in case of a
* crash (i.e. core is generated) we can include the user's data section
* in the core dump. Unfortunately, by default, only a partial core is
* generated which, in many cases, isn't too useful.
*/
struct sigaction nsa;
sigemptyset(&nsa.sa_mask);
nsa.sa_handler = SIG_DFL;
nsa.sa_flags = SA_FULLDUMP;
sigaction(SIGSEGV, &nsa, NULL);
#endif
reinitialize();
if (!parseargs(argc, argv, &cmd)) {
f_print(stderr, "usage: %s infile\n", cmdname);
f_print(stderr,
" %s [-c | -h | -l | -m | -C | -S | -r | -b | -k | -R | -p | -d | -z | -u] [-Pprefix] [-Idir] [-o outfile] [infile]\n",
cmdname);
f_print(stderr, " %s [-s udp|tcp]* [-o outfile] [infile]\n",
cmdname);
exit(1);
}
OutFileFlag = cmd.outfile;
if (OutFileFlag)
strcpy(OutFile, cmd.outfile);
if (cmd.cflag) {
OutFileFlag = NULL;
c_output(cmd.infile, "-DRPC_XDR", !EXTEND, cmd.outfile, 0);
} else if (cmd.hflag) {
h_output(cmd.infile, "-DRPC_HDR", !EXTEND, cmd.outfile, 0);
} else if (cmd.lflag) {
l_output(cmd.infile, "-DRPC_CLNT", !EXTEND, cmd.outfile);
} else if (cmd.sflag || cmd.mflag) {
s_output(argc, argv, cmd.infile, "-DRPC_SVC", !EXTEND, cmd.outfile,
cmd.mflag);
} else if (cmd.Cflag) {
OutFileFlag = NULL;
C_output(cmd.infile, "-DRPC_CLIENT", !EXTEND, cmd.outfile, 1);
} else if (cmd.Sflag) {
OutFileFlag = NULL;
S_output(cmd.infile, "-DRPC_SERVER", !EXTEND, cmd.outfile, 1);
} else {
if (OutFileFlag && (strrchr(OutFile, '.') == NULL))
strcat(OutFile, ".");
if (cmd.rflag) {
C_output((OutFileFlag ? OutFile : cmd.infile), "-DRPC_CLIENT",
EXTEND, ".cs.c", 1);
reinitialize();
S_output((OutFileFlag ? OutFile : cmd.infile), "-DRPC_SERVER",
EXTEND, ".ss.c", 1);
reinitialize();
} else {
reinitialize();
c_output((OutFileFlag ? OutFile : cmd.infile), "-DRPC_XDR",
EXTEND, ".xdr.c", 0);
reinitialize();
h_output((OutFileFlag ? OutFile : cmd.infile), "-DRPC_HDR",
EXTEND, ".h", 0);
reinitialize();
C_output((OutFileFlag ? OutFile : cmd.infile), "-DRPC_CLIENT",
EXTEND, ".cs.c", 1);
reinitialize();
S_output((OutFileFlag ? OutFile : cmd.infile), "-DRPC_SERVER",
EXTEND, ".ss.c", 1);
reinitialize();
}
}
if (fin && pclose_fin) {
/* the cpp command we called returned a non-zero exit status */
if (pclose(fin)) {
crash();
}
}
exit(0);
}
int WEqProcessor::Flush(int fBroadcast)
{
#ifdef _PRINT_DEBUG_INFO
printf("WEqProcessor::Flush\n");
#endif
EnterCriticalSection(&c_CriticalSection);
if(c_nCurrentEqLatency < c_nMaxLatencySamples)
{
// allocate flash buffer
char *buf = (char*) malloc(c_nMaxLatencySamples * c_nBlockAlign);
if(buf == 0)
{
strcpy(c_pchErrorMessageStr, "WEqProcessor::Flush->Memory allocation error.");
if(c_pchReturnError)
strcpy(c_pchReturnError, c_pchErrorMessageStr);
LeaveCriticalSection(&c_CriticalSection);
return 0;
}
memset(buf, 0, c_nMaxLatencySamples * c_nBlockAlign);
if(c_fEnable == 0)
weq_enable = 0;
_ModifySamples(this, (char *) buf, buf, c_nMaxLatencySamples, c_nChannel, c_nBitPerSample);
weq_enable = 1;
_ClearBuffer(this);
c_LastData.nStartPosition = c_LastData.nEndPosition;
c_LastData.nEndPosition += c_nMaxLatencySamples;
c_LastData.pSamples = buf;
c_LastData.nNumberOfSamples = c_nMaxLatencySamples;
c_LastData.nBlockAllign = c_nBlockAlign;
if(c_next)
{
if(c_next->PushSamples(&c_LastData) == 0)
{
free(buf);
LeaveCriticalSection(&c_CriticalSection);
return 0;
}
free(buf);
}
else if (c_output)
{
if(c_output(&c_LastData) == 0)
{
free(buf);
strcpy(c_pchErrorMessageStr, "WEqProcessor::Flush->Output function return 0.");
if(c_pchReturnError)
strcpy(c_pchReturnError, c_pchErrorMessageStr);
LeaveCriticalSection(&c_CriticalSection);
return 0;
}
free(buf);
}
else
{
if(c_queue.PushSamples(&c_LastData) == 0)
{
strcpy(c_pchErrorMessageStr, "WEqProcessor::Flush->Can't add data to queue.");
if(c_pchReturnError)
strcpy(c_pchReturnError, c_pchErrorMessageStr);
LeaveCriticalSection(&c_CriticalSection);
return 0;
}
}
}
c_nLatencyInSamples = 0;
LeaveCriticalSection(&c_CriticalSection);
c_nCurrentEqLatency = Latency;
if(fBroadcast && c_next)
{
#ifdef AUDIO_PROCESSOR_RETURN_ERROR_STR
if(c_pchReturnError == 0)
c_next->c_pchReturnError = c_pchErrorMessageStr;
else
c_next->c_pchReturnError = c_pchReturnError;
#endif
return c_next->Flush(fBroadcast);
}
return 1;
}
int WEqProcessor::PushSamples(PROCESSOR_AUDIO_DATA *data)
{
#ifdef _PRINT_DEBUG_INFO
printf("WEqProcessor::PushData\n");
#endif
EnterCriticalSection(&c_CriticalSection);
unsigned int nDataSize = data->nNumberOfSamples * data->nBlockAllign;
char *pchData = (char*) data->pSamples;
if(c_fEnable)
{
// check if we need to reallocate output buffer
if(c_nOutputBufferSize < nDataSize)
{
char *buf = (char*) malloc(nDataSize);
if(buf == 0)
{
strcpy(c_pchErrorMessageStr, "WEqProcessor::PushData->Memory allocation error.");
LeaveCriticalSection(&c_CriticalSection);
if(c_pchReturnError)
strcpy(c_pchReturnError, c_pchErrorMessageStr);
return 0;
}
if(c_pchOutput)
free(c_pchOutput);
c_pchOutput = buf;
c_nOutputBufferSize = nDataSize;
}
unsigned int nInputSamples = data->nNumberOfSamples;
_ModifySamples(this, (char *) pchData, c_pchOutput, data->nNumberOfSamples, c_nChannel, c_nBitPerSample);
if(c_nCurrentEqLatency)
{
if(c_nCurrentEqLatency >= data->nNumberOfSamples)
{
c_nCurrentEqLatency -= data->nNumberOfSamples;
c_nLatencyInSamples += data->nNumberOfSamples;
LeaveCriticalSection(&c_CriticalSection);
return 1;
}
data->pSamples = c_pchOutput + c_nCurrentEqLatency * c_nBlockAlign;
data->nNumberOfSamples -= c_nCurrentEqLatency;
c_nLatencyInSamples = c_nLatencyInSamples + (nInputSamples - data->nNumberOfSamples);
c_nCurrentEqLatency = 0;
}
else
{
data->pSamples = c_pchOutput;
}
if(c_nLatencyInSamples)
{
// need to fix positions
if(data->nEndPosition >= data->nStartPosition)
{
if(data->nEndPosition >= c_nLatencyInSamples)
data->nEndPosition -= c_nLatencyInSamples;
if(data->nStartPosition >= c_nLatencyInSamples)
data->nStartPosition -= c_nLatencyInSamples;
}
else
{
data->nEndPosition += c_nLatencyInSamples;
data->nStartPosition += c_nLatencyInSamples;
}
}
}
memcpy(&c_LastData, data, sizeof(PROCESSOR_AUDIO_DATA));
LeaveCriticalSection(&c_CriticalSection);
// send data to next processor
if(c_next)
{
#ifdef AUDIO_PROCESSOR_RETURN_ERROR_STR
if(c_pchReturnError == 0)
c_next->c_pchReturnError = c_pchErrorMessageStr;
else
c_next->c_pchReturnError = c_pchReturnError;
#endif
return c_next->PushSamples(data);
}
if(c_output)
{
if(c_output(data) == 0)
{
strcpy(c_pchErrorMessageStr, "WEqProcessor::PushData->Output function return 0.");
if(c_pchReturnError)
strcpy(c_pchReturnError, c_pchErrorMessageStr);
return 0;
}
return 1;
}
if(c_queue.PushSamples(data) == 0)
{
strcpy(c_pchErrorMessageStr, "WEqProcessor::PushData->Can't add data to queue.");
if(c_pchReturnError)
strcpy(c_pchReturnError, c_pchErrorMessageStr);
return 0;
}
return 1;
}
// clear_craft({[output=item], [recipe={{item00,item10},{item01,item11}}])
int ModApiCraft::l_clear_craft(lua_State *L)
{
NO_MAP_LOCK_REQUIRED;
luaL_checktype(L, 1, LUA_TTABLE);
int table = 1;
// Get the writable craft definition manager from the server
IWritableCraftDefManager *craftdef =
getServer(L)->getWritableCraftDefManager();
std::string output = getstringfield_default(L, table, "output", "");
std::string type = getstringfield_default(L, table, "type", "shaped");
CraftOutput c_output(output, 0);
if (output != "") {
if (craftdef->clearCraftRecipesByOutput(c_output, getServer(L)))
return 0;
else
throw LuaError("No craft recipe known for output"
" (output=\"" + output + "\")");
}
std::vector<std::string> recipe;
int width = 0;
CraftMethod method = CRAFT_METHOD_NORMAL;
/*
CraftDefinitionShaped
*/
if (type == "shaped") {
lua_getfield(L, table, "recipe");
if (lua_isnil(L, -1))
throw LuaError("Either output or recipe has to be defined");
if (!readCraftRecipeShaped(L, -1, width, recipe))
throw LuaError("Invalid crafting recipe");
}
/*
CraftDefinitionShapeless
*/
else if (type == "shapeless") {
lua_getfield(L, table, "recipe");
if (lua_isnil(L, -1))
throw LuaError("Either output or recipe has to be defined");
if (!readCraftRecipeShapeless(L, -1, recipe))
throw LuaError("Invalid crafting recipe");
}
/*
CraftDefinitionCooking
*/
else if (type == "cooking") {
method = CRAFT_METHOD_COOKING;
std::string rec = getstringfield_default(L, table, "recipe", "");
if (rec == "")
throw LuaError("Crafting definition (cooking)"
" is missing a recipe");
recipe.push_back(rec);
}
/*
CraftDefinitionFuel
*/
else if (type == "fuel") {
method = CRAFT_METHOD_FUEL;
std::string rec = getstringfield_default(L, table, "recipe", "");
if (rec == "")
throw LuaError("Crafting definition (fuel)"
" is missing a recipe");
recipe.push_back(rec);
} else {
throw LuaError("Unknown crafting definition type: \"" + type + "\"");
}
if (!craftdef->clearCraftRecipesByInput(method, width, recipe, getServer(L)))
throw LuaError("No crafting specified for input");
lua_pop(L, 1);
return 0;
}
int
main(int argc, char **argv)
{
struct commandline cmd;
(void) memset((char *) &cmd, 0, sizeof(struct commandline));
clear_args();
if (!parseargs(argc, argv, &cmd))
usage();
if (cmd.cflag || cmd.hflag || cmd.lflag || cmd.tflag || cmd.sflag ||
cmd.mflag || cmd.nflag || cmd.Ssflag || cmd.Scflag) {
checkfiles(cmd.infile, cmd.outfile);
} else
checkfiles(cmd.infile, NULL);
if (cmd.cflag) {
c_output(cmd.infile, "-DRPC_XDR", DONT_EXTEND, cmd.outfile);
} else if (cmd.hflag) {
h_output(cmd.infile, "-DRPC_HDR", DONT_EXTEND, cmd.outfile);
} else if (cmd.lflag) {
l_output(cmd.infile, "-DRPC_CLNT", DONT_EXTEND, cmd.outfile);
} else if (cmd.sflag || cmd.mflag || (cmd.nflag)) {
s_output(argc, argv, cmd.infile, "-DRPC_SVC", DONT_EXTEND,
cmd.outfile, cmd.mflag, cmd.nflag);
} else if (cmd.tflag) {
t_output(cmd.infile, "-DRPC_TBL", DONT_EXTEND, cmd.outfile);
} else if (cmd.Ssflag) {
svc_output(cmd.infile, "-DRPC_SERVER", DONT_EXTEND, cmd.outfile);
} else if (cmd.Scflag) {
clnt_output(cmd.infile, "-DRPC_CLIENT", DONT_EXTEND, cmd.outfile);
} else {
/* the rescans are required, since cpp may effect input */
c_output(cmd.infile, "-DRPC_XDR", EXTEND, "_xdr.c");
reinitialize();
h_output(cmd.infile, "-DRPC_HDR", EXTEND, ".h");
reinitialize();
l_output(cmd.infile, "-DRPC_CLNT", EXTEND, "_clnt.c");
reinitialize();
if (inetdflag || !tirpcflag)
s_output(allc, allv, cmd.infile, "-DRPC_SVC", EXTEND,
"_svc.c", cmd.mflag, cmd.nflag);
else
s_output(allnc, allnv, cmd.infile, "-DRPC_SVC",
EXTEND, "_svc.c", cmd.mflag, cmd.nflag);
if (tblflag) {
reinitialize();
t_output(cmd.infile, "-DRPC_TBL", EXTEND, "_tbl.i");
}
if (allfiles) {
reinitialize();
svc_output(cmd.infile, "-DRPC_SERVER", EXTEND, "_server.c");
}
if (allfiles) {
reinitialize();
clnt_output(cmd.infile, "-DRPC_CLIENT", EXTEND, "_client.c");
}
}
exit(nonfatalerrors);
/* NOTREACHED */
}
