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 */ }