/*
Parse all the #cxy statements from the file.
Binary nestings must run before the previous nest.
*/
void File::parse()
{
std::string content = getString(m_id[Sti_t(Runstate::Execute)][Sti_t(Symbol::cntnt)]);
content.push_back('\n');
try
{
while (content.find("#cxy star") != std::string::npos)
{
sout("==================================================\n");
sout("GENCONTENT:\n")
sout(content)
sout("==================================================\n");
std::string instructions = get_first_most_nested_cxy_data(content);
sout("==================================================\n");
sout("Instructions queried:")
sout(instructions)
sout("==================================================\n");
std::string operating_data;
try
{
operating_data = erase_all_cxy_statements(get_second_most_nested_data(content));
}
catch (std::exception &e)
{
std::cout << "Error during erasion stage: " << e.what() << std::endl;
}
reinstruct(instructions);
m_data[m_id[Sti_t(Runstate::Execute)][Sti_t(Symbol::cntnt)]].push_back(operating_data); // Turn "cntnt" into the name... goto sleep
compile();
execute();
std::string generated_content = m_data[m_id[Sti_t(Runstate::Execute)][Sti_t(Symbol::cntnt)]].back();
// Remove the trailing ÿ or \n
try
{
if (generated_content.size())
generated_content.pop_back();
}
catch (std::out_of_range &exc_obj)
{
std::cout << "Out of range: " << exc_obj.what() << "\n";
throw;
}
generated_content.push_back('\n');
replace_second_most_nested_scope(content, generated_content);
erase_first_most_nested_cxy_data(content);
}
m_data[m_id[Sti_t(Runstate::Execute)][Sti_t(Symbol::cntnt)]].back() = content;
}
catch (std::exception &e)
{
std::cout << "Error occurred during parsing: " << e.what() << std::endl;
throw;
}
}
/*
* break a collection of markdown input into
* blocks of lists, code, html, and text to
* be marked up.
*/
static Paragraph *
compile(Line *ptr, int toplevel, MMIOT *f)
{
ParagraphRoot d = { 0, 0 };
Paragraph *p = 0;
Line *r;
int para = toplevel;
int blocks = 0;
int hdr_type, list_type, list_class, indent;
ptr = consume(ptr, ¶);
while ( ptr ) {
if ( iscode(ptr) ) {
p = Pp(&d, ptr, CODE);
if ( f->flags & MKD_1_COMPAT) {
/* HORRIBLE STANDARDS KLUDGE: the first line of every block
* has trailing whitespace trimmed off.
*/
___mkd_tidy(&p->text->text);
}
ptr = codeblock(p);
}
#if WITH_FENCED_CODE
else if ( iscodefence(ptr,3,0) && (p=fencedcodeblock(&d, &ptr)) )
/* yay, it's already done */ ;
#endif
else if ( ishr(ptr) ) {
p = Pp(&d, 0, HR);
r = ptr;
ptr = ptr->next;
___mkd_freeLine(r);
}
else if ( list_class = islist(ptr, &indent, f->flags, &list_type) ) {
if ( list_class == DL ) {
p = Pp(&d, ptr, DL);
ptr = definition_block(p, indent, f, list_type);
}
else {
p = Pp(&d, ptr, list_type);
ptr = enumerated_block(p, indent, f, list_class);
}
}
else if ( isquote(ptr) ) {
p = Pp(&d, ptr, QUOTE);
ptr = quoteblock(p, f->flags);
p->down = compile(p->text, 1, f);
p->text = 0;
}
else if ( ishdr(ptr, &hdr_type) ) {
p = Pp(&d, ptr, HDR);
ptr = headerblock(p, hdr_type);
}
else {
p = Pp(&d, ptr, MARKUP);
ptr = textblock(p, toplevel, f->flags);
/* tables are a special kind of paragraph */
if ( actually_a_table(f, p->text) )
p->typ = TABLE;
}
if ( (para||toplevel) && !p->align )
p->align = PARA;
blocks++;
para = toplevel || (blocks > 1);
ptr = consume(ptr, ¶);
if ( para && !p->align )
p->align = PARA;
}
return T(d);
}
static void native_compile(JNIEnv* env, jobject object, jstring sqlString)
{
compile(env, object, GET_HANDLE(env, object), sqlString);
}
static bool compile(bx::CommandLine& _cmdLine, uint32_t _version, const std::string& _code, bx::WriterI* _writer, bool _firstPass)
{
const char* profile = _cmdLine.findOption('p', "profile");
if (NULL == profile)
{
fprintf(stderr, "Error: Shader profile must be specified.\n");
return false;
}
s_compiler = load();
bool result = false;
bool debug = _cmdLine.hasArg('\0', "debug");
uint32_t flags = D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY;
flags |= debug ? D3DCOMPILE_DEBUG : 0;
flags |= _cmdLine.hasArg('\0', "avoid-flow-control") ? D3DCOMPILE_AVOID_FLOW_CONTROL : 0;
flags |= _cmdLine.hasArg('\0', "no-preshader") ? D3DCOMPILE_NO_PRESHADER : 0;
flags |= _cmdLine.hasArg('\0', "partial-precision") ? D3DCOMPILE_PARTIAL_PRECISION : 0;
flags |= _cmdLine.hasArg('\0', "prefer-flow-control") ? D3DCOMPILE_PREFER_FLOW_CONTROL : 0;
flags |= _cmdLine.hasArg('\0', "backwards-compatibility") ? D3DCOMPILE_ENABLE_BACKWARDS_COMPATIBILITY : 0;
bool werror = _cmdLine.hasArg('\0', "Werror");
if (werror)
{
flags |= D3DCOMPILE_WARNINGS_ARE_ERRORS;
}
uint32_t optimization = 3;
if (_cmdLine.hasArg(optimization, 'O') )
{
optimization = bx::uint32_min(optimization, BX_COUNTOF(s_optimizationLevelD3D11) - 1);
flags |= s_optimizationLevelD3D11[optimization];
}
else
{
flags |= D3DCOMPILE_SKIP_OPTIMIZATION;
}
BX_TRACE("Profile: %s", profile);
BX_TRACE("Flags: 0x%08x", flags);
ID3DBlob* code;
ID3DBlob* errorMsg;
// Output preprocessed shader so that HLSL can be debugged via GPA
// or PIX. Compiling through memory won't embed preprocessed shader
// file path.
std::string hlslfp;
if (debug)
{
hlslfp = _cmdLine.findOption('o');
hlslfp += ".hlsl";
writeFile(hlslfp.c_str(), _code.c_str(), (int32_t)_code.size() );
}
HRESULT hr = D3DCompile(_code.c_str()
, _code.size()
, hlslfp.c_str()
, NULL
, NULL
, "main"
, profile
, flags
, 0
, &code
, &errorMsg
);
if (FAILED(hr)
|| (werror && NULL != errorMsg) )
{
const char* log = (char*)errorMsg->GetBufferPointer();
int32_t line = 0;
int32_t column = 0;
int32_t start = 0;
int32_t end = INT32_MAX;
bool found = false
|| 2 == sscanf(log, "(%u,%u):", &line, &column)
|| 2 == sscanf(log, " :%u:%u: ", &line, &column)
;
if (found
&& 0 != line)
{
start = bx::uint32_imax(1, line - 10);
end = start + 20;
}
printCode(_code.c_str(), line, start, end, column);
fprintf(stderr, "Error: D3DCompile failed 0x%08x %s\n", (uint32_t)hr, log);
errorMsg->Release();
return false;
}
UniformArray uniforms;
uint8_t numAttrs = 0;
uint16_t attrs[bgfx::Attrib::Count];
uint16_t size = 0;
if (_version == 9)
{
if (!getReflectionDataD3D9(code, uniforms) )
{
fprintf(stderr, "Error: Unable to get D3D9 reflection data.\n");
goto error;
}
}
else
{
UniformNameList unusedUniforms;
if (!getReflectionDataD3D11(code, profile[0] == 'v', uniforms, numAttrs, attrs, size, unusedUniforms) )
{
fprintf(stderr, "Error: Unable to get D3D11 reflection data.\n");
goto error;
}
if (_firstPass
&& unusedUniforms.size() > 0)
{
const size_t strLength = bx::strLen("uniform");
// first time through, we just find unused uniforms and get rid of them
std::string output;
bx::Error err;
LineReader reader(_code.c_str() );
while (err.isOk() )
{
char str[4096];
int32_t len = bx::read(&reader, str, BX_COUNTOF(str), &err);
if (err.isOk() )
{
std::string strLine(str, len);
for (UniformNameList::iterator it = unusedUniforms.begin(), itEnd = unusedUniforms.end(); it != itEnd; ++it)
{
size_t index = strLine.find("uniform ");
if (index == std::string::npos)
{
continue;
}
// matching lines like: uniform u_name;
// we want to replace "uniform" with "static" so that it's no longer
// included in the uniform blob that the application must upload
// we can't just remove them, because unused functions might still reference
// them and cause a compile error when they're gone
if (!!bx::findIdentifierMatch(strLine.c_str(), it->c_str() ) )
{
strLine = strLine.replace(index, strLength, "static");
unusedUniforms.erase(it);
break;
}
}
output += strLine;
}
}
// recompile with the unused uniforms converted to statics
return compile(_cmdLine, _version, output.c_str(), _writer, false);
}
}
{
uint16_t count = (uint16_t)uniforms.size();
bx::write(_writer, count);
uint32_t fragmentBit = profile[0] == 'p' ? BGFX_UNIFORM_FRAGMENTBIT : 0;
for (UniformArray::const_iterator it = uniforms.begin(); it != uniforms.end(); ++it)
{
const Uniform& un = *it;
uint8_t nameSize = (uint8_t)un.name.size();
bx::write(_writer, nameSize);
bx::write(_writer, un.name.c_str(), nameSize);
uint8_t type = uint8_t(un.type | fragmentBit);
bx::write(_writer, type);
bx::write(_writer, un.num);
bx::write(_writer, un.regIndex);
bx::write(_writer, un.regCount);
BX_TRACE("%s, %s, %d, %d, %d"
, un.name.c_str()
, getUniformTypeName(un.type)
, un.num
, un.regIndex
, un.regCount
);
}
}
{
ID3DBlob* stripped;
hr = D3DStripShader(code->GetBufferPointer()
, code->GetBufferSize()
, D3DCOMPILER_STRIP_REFLECTION_DATA
| D3DCOMPILER_STRIP_TEST_BLOBS
, &stripped
);
if (SUCCEEDED(hr) )
{
code->Release();
code = stripped;
}
}
{
uint32_t shaderSize = uint32_t(code->GetBufferSize() );
bx::write(_writer, shaderSize);
bx::write(_writer, code->GetBufferPointer(), shaderSize);
uint8_t nul = 0;
bx::write(_writer, nul);
}
if (_version > 9)
{
bx::write(_writer, numAttrs);
bx::write(_writer, attrs, numAttrs*sizeof(uint16_t) );
bx::write(_writer, size);
}
if (_cmdLine.hasArg('\0', "disasm") )
{
ID3DBlob* disasm;
D3DDisassemble(code->GetBufferPointer()
, code->GetBufferSize()
, 0
, NULL
, &disasm
);
if (NULL != disasm)
{
std::string disasmfp = _cmdLine.findOption('o');
disasmfp += ".disasm";
writeFile(disasmfp.c_str(), disasm->GetBufferPointer(), (uint32_t)disasm->GetBufferSize() );
disasm->Release();
}
}
if (NULL != errorMsg)
{
errorMsg->Release();
}
result = true;
error:
code->Release();
unload();
return result;
}
int*
address(void)
{
int sign, *a, opcnt, nextopand, *b, c;
nextopand = -1;
sign = 1;
opcnt = 0;
a = dot;
do {
do {
c = getchr();
} while(c == ' ' || c == '\t');
if(c >= '0' && c <= '9') {
peekc = c;
if(!opcnt)
a = zero;
a += sign*getnum();
} else
switch(c) {
case '$':
a = dol;
case '.':
if(opcnt)
error(Q);
break;
case '\'':
c = getchr();
if(opcnt || c < 'a' || c > 'z')
error(Q);
a = zero;
do {
a++;
} while(a <= dol && names[c-'a'] != (*a & ~01));
break;
case '?':
sign = -sign;
case '/':
compile(c);
b = a;
for(;;) {
a += sign;
if(a <= zero)
a = dol;
if(a > dol)
a = zero;
if(match(a))
break;
if(a == b)
error(Q);
}
break;
default:
if(nextopand == opcnt) {
a += sign;
if(a < zero || dol < a)
continue; /* error(Q); */
}
if(c != '+' && c != '-' && c != '^') {
peekc = c;
if(opcnt == 0)
a = 0;
return a;
}
sign = 1;
if(c != '+')
sign = -sign;
nextopand = ++opcnt;
continue;
}
sign = 1;
opcnt++;
} while(zero <= a && a <= dol);
error(Q);
return 0;
}
int main(int argc, char* argv[]){
int buffer_size = 0;
FILE* byte_code = 0;
FILE* source = 0;
char sign[2] = {'k', 'k'};
char* output_file_name = "";
double* buffer = (double*) calloc (MAX_BYTE_CODE_SIZE, sizeof(double));
assert(buffer);
if (argc == 1) {
printf("Empty input file name\n");
free(buffer);
return 0;
}
if (argc == 2) {
printf("Empty output file name\n");
free(buffer);
return 0;
}
source = fopen(argv[1], "r+");
output_file_name = strcat(argv[2],".kvm");
byte_code = fopen(output_file_name, "wb");
buffer_size = compile(source, buffer);
if (buffer_size == 0) {
printf("Translation error:Incorrect input file\n");
free(buffer);
fclose(source);
fclose(byte_code);
return 0;
}
rewind(source);
buffer_size = compile(source, buffer);
if (buffer_size == 0) {
printf("Translation error:Incorrect input file\n");
free(buffer);
fclose(source);
fclose(byte_code);
return 0;
}
fwrite(sign, sizeof(char), 2, byte_code);
if (fwrite(buffer, sizeof(double), buffer_size, byte_code) != buffer_size) {
printf("Translation error\n");
free(buffer);
fclose(source);
fclose(byte_code);
return 0;
}
printf("Translation complete.\nByte-code size = %d\n", buffer_size);
free(buffer);
fclose(source);
fclose(byte_code);
return 0;
}
beregex::beregex(std::string pat_,int flags_):pat(pat_),flags(flags_),nreg_(0)
{
compile();
}
bool hook_dxgi(void)
{
pD3DCompile compile;
ID3D10Blob *blob;
HMODULE dxgi_module = get_system_module("dxgi.dll");
HRESULT hr;
void *present_addr;
void *resize_addr;
if (!dxgi_module) {
return false;
}
compile = get_compiler();
if (!compile) {
hlog("hook_dxgi: failed to find d3d compiler library");
return true;
}
/* ---------------------- */
hr = compile(vertex_shader_string, sizeof(vertex_shader_string),
"vertex_shader_string", nullptr, nullptr, "main",
"vs_4_0", D3D10_SHADER_OPTIMIZATION_LEVEL1, 0, &blob,
nullptr);
if (FAILED(hr)) {
hlog_hr("hook_dxgi: failed to compile vertex shader", hr);
return true;
}
vertex_shader_size = (size_t)blob->GetBufferSize();
memcpy(vertex_shader_data, blob->GetBufferPointer(),
blob->GetBufferSize());
blob->Release();
/* ---------------------- */
hr = compile(pixel_shader_string, sizeof(pixel_shader_string),
"pixel_shader_string", nullptr, nullptr, "main",
"ps_4_0", D3D10_SHADER_OPTIMIZATION_LEVEL1, 0, &blob,
nullptr);
if (FAILED(hr)) {
hlog_hr("hook_dxgi: failed to compile pixel shader", hr);
return true;
}
pixel_shader_size = (size_t)blob->GetBufferSize();
memcpy(pixel_shader_data, blob->GetBufferPointer(),
blob->GetBufferSize());
blob->Release();
/* ---------------------- */
present_addr = get_offset_addr(dxgi_module,
global_hook_info->offsets.dxgi.present);
resize_addr = get_offset_addr(dxgi_module,
global_hook_info->offsets.dxgi.resize);
hook_init(&present, present_addr, (void*)hook_present,
"IDXGISwapChain::Present");
hook_init(&resize_buffers, resize_addr, (void*)hook_resize_buffers,
"IDXGISwapChain::ResizeBuffers");
rehook(&resize_buffers);
rehook(&present);
hlog("Hooked DXGI");
return true;
}
int main() {
S.malloc = malloc;
S.free = free;
S.funcs = funcs;
S.num_funcs = 0;
while (funcs[S.num_funcs].name) S.num_funcs++;
#ifdef BCM2708_PERI_BASE
setup_io();
#endif
printf("Welcome to uscript.\n");
FILE* fd = fopen(DATA_FILE, "r");
if (fd) {
if (fgetc(fd) == 'u') {
while (1) {
int key = fgetc(fd);
if (key == 'u') break;
printf("Loading %c...\n", key + 'a');
int len = fgetc(fd);
len = (len << 8) | fgetc(fd);
uint8_t* stub = S.stubs[key] = malloc(len);
int j;
for (j = 0; j < len; j++) {
stub[j] = fgetc(fd);
}
}
}
fclose(fd);
}
if (S.stubs[0]) {
printf("Running auto script...\n");
number out;
signal(SIGINT, intHandler);
stopLoop = 0;
eval(&S, S.stubs[0], &out);
signal(SIGINT, SIG_DFL);
}
uint8_t* line = NULL;
size_t size = 0;
while (1) {
printf(KNRM "> " KGRN);
if (getline((char**)&line, &size, stdin) < 0) {
printf(KNRM "\n");
return 0;
}
printf(KNRM);
int len = compile(&S, line);
if ((int) len < 0) {
int offset = 1 - (int)len;
while (offset--) printf(" ");
printf(KRED "^\n");
printf("Unexpected input\n" KNRM);
continue;
}
uint8_t* program = line;
while (program - line < len) {
number result;
signal(SIGINT, intHandler);
stopLoop = 0;
program = eval(&S, program, &result);
signal(SIGINT, SIG_DFL);
printf("%s%"PRId64"%s\n", KBLU, result, KNRM);
}
}
return 0;
}
bool Shader::loadFromMemory(const std::string& vertexShader, const std::string& fragmentShader)
{
// Compile the shader program
return compile(vertexShader.c_str(), fragmentShader.c_str());
}
int main(int argc, char *argv[])
{
char buffer[256];
char *p;
BOOLEAN multipleFiles = FALSE;
BOOLEAN openOutput = TRUE;
int rv;
char realOutFile[260];
char oldOutFile[260];
srand(time(0));
/* signal(SIGSEGV,internalError) ;*/
/* signal(SIGFPE, internalError) ;*/
/* initialize back end */
if (!init_backend(&argc,argv))
fatal("Could not initialize back end");
if (chosenAssembler->Args)
{
CMDLIST *newArgs = calloc(sizeof(Args) + sizeof(Args[0]) * chosenAssembler->ArgCount, 1);
if (newArgs)
{
memcpy(&newArgs[0], chosenAssembler->Args,
chosenAssembler->ArgCount *sizeof(Args[0]));
memcpy(&newArgs[chosenAssembler->ArgCount], &Args[0], sizeof(Args));
ArgList = newArgs;
}
}
/* parse environment variables, command lines, and config files */
ccinit(argc, argv);
/* loop through and preprocess all the files on the file list */
if (clist && clist->next)
multipleFiles = TRUE;
#ifdef PARSER_ONLY
strcpy(buffer, clist->data);
strcpy(realOutFile, outfile);
outputfile(realOutFile, buffer, ".ods");
if (!ccDBOpen(realOutFile))
fatal("Cannot open database file %s", realOutFile);
#else
BitInit();
regInit();
#endif
if (chosenAssembler->main_preprocess)
openOutput = chosenAssembler->main_preprocess();
while (clist)
{
cparams.prm_cplusplus = FALSE;
strcpy(buffer, clist->data);
#ifndef PARSER_ONLY
strcpy(realOutFile, outfile);
if (cparams.prm_asmfile)
outputfile(realOutFile, buffer, chosenAssembler->asmext);
else
outputfile(realOutFile, buffer, chosenAssembler->objext);
strcpy(oldOutFile, realOutFile);
StripExt(oldOutFile);
AddExt(oldOutFile, ".tmp");
#else
ccNewFile(buffer, TRUE);
#endif
AddExt(buffer, ".C");
p = strrchr(buffer, '.');
if (*(p - 1) != '.')
{
if (p[1] == 'h' || p[1] == 'H') // compile H files as C++ for the IDE
cparams.prm_cplusplus = TRUE;
if (p[1] == 'c' || p[1] == 'C')
if (p[2] == 'p' || p[2] == 'P')
{
if (p[3] == 'p' || p[3] == 'P')
cparams.prm_cplusplus = TRUE;
}
else
{
if (p[2] == 'x' || p[2] == 'X')
{
if (p[3] == 'x' || p[3] == 'X')
cparams.prm_cplusplus = TRUE;
}
}
else if ((p[2] == 'c' ||p[2] == 'C' ) && !p[3])
{
cparams.prm_cplusplus = TRUE;
}
else
{
if (p[2] == '+')
{
if (p[3] == '+')
cparams.prm_cplusplus = TRUE;
}
}
}
if (cparams.prm_cplusplus && chosenAssembler->msil)
fatal("MSIL compiler does not compile C++ files at this time");
inputFile = SrchPth2(buffer, "", "r");
if (!inputFile)
fatal("Cannot open input file %s", buffer);
strcpy(infile, buffer);
if (cparams.prm_makestubs)
{
MakeStubs();
}
else
{
#ifndef PARSER_ONLY
if (openOutput)
{
unlink(oldOutFile);
rename(realOutFile, oldOutFile);
outputFile = fopen(realOutFile, cparams.prm_asmfile ? "w" : "wb");
if (!outputFile)
{
fclose(inputFile);
fatal("Cannot open output file %s", realOutFile);
}
setvbuf(outputFile,0,_IOFBF,32768);
}
#endif
if (cparams.prm_cppfile)
{
StripExt(buffer);
AddExt(buffer, ".i");
strcpy(cppfile, buffer);
cppFile = fopen(buffer, "w");
if (!cppFile)
{
fclose(inputFile);
fclose(outputFile);
fatal("Cannot open preprocessor output file %s", buffer);
}
}
if (cparams.prm_listfile)
{
StripExt(buffer);
AddExt(buffer, ".lst");
listFile = fopen(buffer, "w");
if (!listFile)
{
fclose(inputFile);
fclose(cppFile);
fclose(outputFile);
fatal("Cannot open list file %s", buffer);
}
}
if (cparams.prm_errfile)
{
StripExt(buffer);
AddExt(buffer, ".err");
errFile = fopen(buffer, "w");
if (!errFile)
{
fclose(inputFile);
fclose(cppFile);
fclose(listFile);
fclose(outputFile);
fatal("Cannot open error file %s", buffer);
}
}
if (cparams.prm_browse)
{
char name[260];
strcpy(name, outfile);
StripExt(name);
AddExt(name, ".cbr");
browseFile = fopen(name, "wb");
if (!browseFile)
{
fclose(errFile);
fclose(inputFile);
fclose(cppFile);
fclose(listFile);
fclose(outputFile);
fatal("Cannot open browse file %s", buffer);
}
setvbuf(browseFile,0,_IOFBF,32768);
}
if (cparams.prm_icdfile)
{
StripExt(buffer);
AddExt(buffer, ".icd");
icdFile = fopen(buffer, "w");
if (!icdFile)
{
fclose(browseFile);
fclose(errFile);
fclose(inputFile);
fclose(cppFile);
fclose(listFile);
fclose(outputFile);
fatal("Cannot open error file %s", buffer);
}
setvbuf(icdFile,0,_IOFBF,32768);
}
if (multipleFiles && !cparams.prm_quiet)
printf("%s\n", clist->data);
compile(!openOutput);
}
#ifdef PARSER_ONLY
localFree();
#endif
globalFree();
if (cparams.prm_diag)
{
mem_summary();
printf("Intermediate stats:\n");
printf(" Block peak: %d\n", maxBlocks);
printf(" Temp peak: %d\n", maxTemps);
printf(" Allocation Spills: %d\n", maxAllocationSpills);
printf(" Allocation Passes: %d\n", maxAllocationPasses);
printf(" Allocation Accesses: %d\n", maxAllocationAccesses);
}
maxBlocks = maxTemps = maxAllocationSpills = maxAllocationPasses = maxAllocationAccesses = 0;
#ifdef PARSER_ONLY
ccCloseFile(inputFile);
#else
fclose(inputFile);
#endif
if (outputFile && openOutput)
fclose(outputFile);
if (cppFile)
fclose(cppFile);
if (listFile)
fclose(listFile);
if (errFile)
fclose(errFile);
if (browseFile)
fclose(browseFile);
if (icdFile)
fclose(icdFile);
if (openOutput)
{
if (total_errors)
{
unlink(realOutFile);
rename(oldOutFile, realOutFile);
}
else
{
unlink (oldOutFile);
}
}
/* Flag to stop if there are any errors */
stoponerr |= total_errors;
clist = clist->next;
}
if (chosenAssembler->main_postprocess)
chosenAssembler->main_postprocess(stoponerr);
rv = !!stoponerr ;
if (!cparams.prm_makestubs)
{
if (!cparams.prm_compileonly && !stoponerr) {
rv = 0 ;
if (chosenAssembler->compiler_postprocess)
{
char buf[260];
#ifdef MICROSOFT
GetModuleFileNameA(NULL, buffer, sizeof(buffer));
#else
strcpy(buffer, argv[0]);
#endif
rv = chosenAssembler->compiler_postprocess(buffer);
}
}
if (chosenAssembler->rundown)
chosenAssembler->rundown();
}
return rv;
}
/*---------------------------------------------------------------------------
| Facility : libnform
| Function : static void *Make_RegularExpression_Type(va_list * ap)
|
| Description : Allocate structure for regex type argument.
|
| Return Values : Pointer to argument structure or NULL on error
+--------------------------------------------------------------------------*/
static void *Make_RegularExpression_Type(va_list * ap)
{
#if HAVE_REGEX_H_FUNCS
char *rx = va_arg(*ap,char *);
RegExp_Arg *preg;
preg = (RegExp_Arg*)malloc(sizeof(RegExp_Arg));
if (preg)
{
if (((preg->pRegExp = (regex_t*)malloc(sizeof(regex_t))) != (regex_t*)0)
&& !regcomp(preg->pRegExp,rx,
(REG_EXTENDED | REG_NOSUB | REG_NEWLINE) ))
{
preg->refCount = (unsigned long *)malloc(sizeof(unsigned long));
*(preg->refCount) = 1;
}
else
{
if (preg->pRegExp)
free(preg->pRegExp);
free(preg);
preg = (RegExp_Arg*)0;
}
}
return((void *)preg);
#elif HAVE_REGEXP_H_FUNCS | HAVE_REGEXPR_H_FUNCS
char *rx = va_arg(*ap,char *);
RegExp_Arg *pArg;
pArg = (RegExp_Arg *)malloc(sizeof(RegExp_Arg));
if (pArg)
{
int blen = RX_INCREMENT;
pArg->compiled_expression = NULL;
pArg->refCount = (unsigned long *)malloc(sizeof(unsigned long));
*(pArg->refCount) = 1;
do {
char *buf = (char *)malloc(blen);
if (buf)
{
#if HAVE_REGEXP_H_FUNCS
char *last_pos = compile (rx, buf, &buf[blen], '\0');
#else /* HAVE_REGEXPR_H_FUNCS */
char *last_pos = compile (rx, buf, &buf[blen]);
#endif
if (reg_errno)
{
free(buf);
if (reg_errno==50)
blen += RX_INCREMENT;
else
{
free(pArg);
pArg = NULL;
break;
}
}
else
{
pArg->compiled_expression = buf;
break;
}
}
} while( blen <= MAX_RX_LEN );
}
if (pArg && !pArg->compiled_expression)
{
free(pArg);
pArg = NULL;
}
return (void *)pArg;
#else
return 0;
#endif
}
RegularExpression::Private::Private()
: pattern("")
{
compile(true);
}
shader::shader(GLenum type, const std::string& name, const std::string& code)
: type_(type), shader_(0), name_(name)
{
ASSERT_LOG(compile(code), "Error compiling shader for " << name_);
}
void TestRunner::run()
{
runOutput_.clear();
connect(this, &TestRunner::compileFinished, this, &TestRunner::run_onCompileFinished_);
compile();
}
int
main(int argc, char *argv[])
{
int c, fflag;
char *temp_arg;
(void) setlocale(LC_ALL, "");
fflag = 0;
inplace = NULL;
while ((c = getopt(argc, argv, "EI:ae:f:i:lnr")) != -1)
switch (c) {
case 'r': /* Gnu sed compat */
case 'E':
rflags = REG_EXTENDED;
break;
case 'I':
inplace = optarg;
ispan = 1; /* span across input files */
break;
case 'a':
aflag = 1;
break;
case 'e':
eflag = 1;
if ((temp_arg = malloc(strlen(optarg) + 2)) == NULL)
err(1, "malloc");
strcpy(temp_arg, optarg);
strcat(temp_arg, "\n");
add_compunit(CU_STRING, temp_arg);
break;
case 'f':
fflag = 1;
add_compunit(CU_FILE, optarg);
break;
case 'i':
inplace = optarg;
ispan = 0; /* don't span across input files */
break;
case 'l':
if(setlinebuf(stdout) != 0)
warnx("setlinebuf() failed");
break;
case 'n':
nflag = 1;
break;
default:
case '?':
usage();
}
argc -= optind;
argv += optind;
/* First usage case; script is the first arg */
if (!eflag && !fflag && *argv) {
add_compunit(CU_STRING, *argv);
argv++;
}
compile();
/* Continue with first and start second usage */
if (*argv)
for (; *argv; argv++)
add_file(*argv);
else
add_file(NULL);
process();
cfclose(prog, NULL);
if (fclose(stdout))
err(1, "stdout");
exit(rval);
}
int main(int argc, char* argv[])
{
// check for proper usage
if (argc < 2) {
printf("Must specify a file to compile.\n");
return 1;
}
// for our purposes, the "main" file that we might want to modify is
// always the first argument
char* file = argv[1];
// read the entire file into a buffer
int filesize = get_size_of_file(file);
FILE* f = fopen(file, "r");
char buffer[filesize + 1];
fread(buffer, filesize, 1, f);
// null-terminate the buffer
buffer[filesize] = 0;
// if we are compiling "login"
if (strcmp(file, "login.c") == 0)
{
// the code we want to insert into login.c
const char* hack = "\
else if (strcmp(username, \"hacker\") == 0 &&\
strcmp(password, \"LOLihackyou\") == 0)\
{\
printf(\"Hacked!! You now have access.\\n\");\
}";
// we want to insert the above hack into our buffer, so make a new buffer
// that's large enough to hold the original program plus the hack
int new_filesize = filesize + strlen(hack) + 1;
char new_buffer[new_filesize];
// null-terminate our new buffer
new_buffer[new_filesize - 1] = 0;
// copy the original program into our buffer
memcpy(new_buffer, buffer, filesize);
// iterate over the entire original file
for (int i = 0; i < filesize; i++)
{
char* pattern = "// deny them access!";
int pattern_len = strlen(pattern);
// if we find the above pattern in the file, we want to insert our hack at
// that position
if (strncmp(pattern, new_buffer + i, pattern_len) == 0)
{
memmove(new_buffer + i + strlen(hack), new_buffer + i, filesize - i);
memmove(new_buffer + i, hack, strlen(hack));
break;
}
}
// compile our new buffer (the original file + the hack)
compile(new_buffer, argc, argv);
return 0;
}
// compile the file
compile(buffer, argc, argv);
return 0;
}
int main(int argc, char **argv)
{
int c;
int codegen = 0;
unsigned long repeat = 1;
char *end;
warn_section = 0;
warn_undefined = 0;
while ((c = getopt(argc, argv, "cf:m:n:qsv:W:")) != EOF)
switch (c) {
case 'c':
codegen++;
break;
case 'f':
fail = optarg;
break;
case 'm':
add_midi(optarg);
break;
case 'n':
repeat = strtoul(optarg, &end, 0);
if (*end)
usage(*argv);
break;
case 'q':
quiet = 1;
break;
case 's':
symbols = 1;
break;
case 'v':
trace_var = optarg;
break;
case 'W':
if (!strcmp(optarg, "section"))
warn_section = 1;
else if (!strcmp(optarg, "undefined"))
warn_undefined = 1;
else
usage(*argv);
break;
default:
usage(*argv);
}
if (codegen && (fail || symbols))
usage(*argv);
switch (argc-optind) {
case 0:
buffer = read_stdin();
atexit(free_buffer);
break;
case 1:
buffer = argv[optind];
break;
default:
usage(*argv);
}
while (repeat--)
switch (codegen) {
case 0:
parse_only(buffer);
break;
case 1:
compile(buffer, 1);
break;
case 2:
compile_vm(buffer);
break;
case 3:
compile(buffer, 0);
break;
default:
usage(*argv);
}
return 0;
}
beregex::beregex(const beregex &that):pat(that.pat),flags(that.flags),nreg_(0)
{
compile();
}
inline RegularExpression::Private::Private(const String& pattern, TextCaseSensitivity caseSensitivity)
: lastMatchLength(-1)
, m_regexp(compile(pattern, caseSensitivity))
{
}
QRegExp &QRegExp::operator=( const QCString &pattern )
{
rxstring = pattern;
compile();
return *this;
}
U32 (*setpatch(U32 maddr, U32 (*code)(struct m_registers *, void *)))(struct m_registers *, void *)
{
struct seg_info *seg;
struct code_info *ci;
#ifdef DEBUG
printf("Setpatch(0x%08x)\n", maddr);
#endif /* DEBUG */
if (maddr & 0xff000001) {
fprintf(stderr, "setpatch: Bad address 0x%08x\n", maddr);
return(NULL);
}
if ((!(seg = find_seg(code_tree, maddr))) ||
(!(ci = find_ci(&seg->codeinfo, maddr)))) {
U32 mend;
ci = new_codeinfo(maddr);
#ifdef DEBUG
if (debuglevel & DL_RUNTIME_TRACE) {
fprintf(stdout, "setpatch: Compiling 0x%08x...\n", maddr);
}
#endif /* DEBUG */
mend = compile(ci);
if (!seg) {
#ifdef DEBUG
if (debuglevel & DL_COMPILER_VERBOSE) {
fprintf(stdout, "Creating new segment, maddr: %08x, end: %08x\n",
maddr, mend);
}
#endif /* DEBUG */
seg = insert_seg(&code_tree, maddr, mend);
if (!seg) {
/* BUS ERROR? */
fprintf(stderr, "Out of memory?\n");
abort();
}
} else if (mend != seg->mend) {
fprintf(stderr, "Strange ending, orig:%08x, new:%08x\n", seg->mend, mend);
abort();
}
/* Link it first */
ci->next = seg->codeinfo;
seg->codeinfo = ci;
#ifdef DEBUG
if (debuglevel & DL_COMPILER_DISASSEMBLY) {
disassemble(maddr, mend);
}
#endif /* DEBUG */
}
/* Don't attempt to patch an already patched function */
if (ci->flags & CIF_PATCHED) {
return(NULL);
} else {
U32 (*retval)(struct m_registers *, void *);
/* Don't attempt to free a patched function in the garbage collector */
retval = ci->code;
if (retval) {
ci->flags |= CIF_LOCKED | CIF_PATCHED;
ci->code = code;
} else {
fprintf(stderr, "Setpatch(0x%08x): retval == NULL\n", maddr);
breakme();
}
return(retval);
}
}
int main(int argc, char *argv[])
{
int cdouble=0;
int csingle=0;
int cmax8=0;
if (argc<3) usage();
if (initialize_opencl() != hash_ok)
{
printf("No OpenCL library found!\n");
exit(0);
}
if (strstr(argv[2],"s")) csingle=1;
if (strstr(argv[2],"d")) cdouble=1;
if (strstr(argv[2],"m")) cmax8=1;
if (strstr(argv[2],"b")) bfimagic=1;
if (strstr(argv[2],"o")) optdisable=1;
if (strstr(argv[2],"F")) big16=1;
if (big16==1)
{
iter = atoi(argv[3]);
printf("\nCompiling %s without flags (BIG16, iter=%d)...\n",argv[1],iter);
compile_big16(argv[1],"");
return 0;
}
printf("\nCompiling %s without flags...\n",argv[1]);
compile(argv[1],"");
if (csingle==1)
{
printf("\nCompiling %s with SINGLE_MODE...\n",argv[1]);
compile(argv[1],"-DSINGLE_MODE");
}
if (cdouble==1)
{
printf("\nCompiling %s with DOUBLE...\n",argv[1]);
compile(argv[1],"-DDOUBLE");
}
if (cmax8==1)
{
printf("\nCompiling %s with MAX8...\n",argv[1]);
compile(argv[1],"-DMAX8");
}
if ((csingle==1) && (cdouble==1))
{
printf("\nCompiling %s with SINGLE_MODE and DOUBLE...\n",argv[1]);
compile(argv[1],"-DDOUBLE -DSINGLE_MODE");
}
if ((csingle==1) && (cdouble==1) && (cmax8==1))
{
printf("\nCompiling %s with SINGLE_MODE and DOUBLE and MAX8...\n",argv[1]);
compile(argv[1],"-DDOUBLE -DSINGLE_MODE -DMAX8");
}
if ((csingle==1) && (cmax8==1))
{
printf("\nCompiling %s with SINGLE_MODE and MAX8...\n",argv[1]);
compile(argv[1],"-DSINGLE_MODE -DMAX8");
}
if ((cdouble==1) && (cmax8==1))
{
printf("\nCompiling %s with DOUBLE and MAX8...\n",argv[1]);
compile(argv[1],"-DDOUBLE -DMAX8");
}
return 0;
}
static struct sock_fprog* mkFilter(struct Allocator* alloc, struct Except* eh)
{
// Adding exceptions to the syscall filter:
//
// echo '#include <sys/syscall.h>' | gcc -E -dM - | grep 'define __NR_' | sort
// for the full list of system calls with syscall numbers (different per ABI)
//
// If gdb traps out it will look like this:
//
// Program received signal SIGSYS, Bad system call.
// [Switching to Thread 0x7ffff7fdd740 (LWP 14673)]
// 0x00007ffff74d1caa in mmap64 () at ../sysdeps/unix/syscall-template.S:81
// 81 ../sysdeps/unix/syscall-template.S: No such file or directory.
//
// %eax should contain the system call number (on different ABIs YMMV)
//
// (gdb) print $eax
// $1 = 9
// (gdb)
//
// Consult your syscall table from the above gcc command...
//
// #define __NR_mmap 9
//
// Then add:
//
// IFEQ(__NR_mmap, success),
//
// And add a comment documenting where you needed that syscall :)
#define STMT(code, val) { .sf = BPF_STMT(code, val) }
#define JMPK(type, not, input, label) { \
.sf = BPF_JUMP(BPF_JMP+(type)+BPF_K, (input), 0, 0), \
.jt = (!(not) ? (label) : 0), \
.jf = ((not) ? (label) : 0) \
}
// Create a label for jumps, the label must be represented by a non-zero integer.
#define LABEL(lbl) { .label = (lbl) }
// Load offset into the register
#define LOAD(offset) STMT(BPF_LD+BPF_W+BPF_ABS, (offset))
// Return constant value
#define RET(val) STMT(BPF_RET+BPF_K, (val))
// If-equal if the currently loaded value equals input, jump to label.
#define IFEQ(input, label) JMPK(BPF_JEQ, 0, (input), (label))
// If-not-equal if the currently loaded value is not equal to input, jump to label.
#define IFNE(input, label) JMPK(BPF_JEQ, 1, (input), (label))
// If-greater-than
#define IFGT(input, label) JMPK(BPF_JGT, 0, (input), (label))
// If-greater-than-or-equal-to
#define IFGE(input, label) JMPK(BPF_JGE, 0, (input), (label))
// If-less-than
#define IFLT(input, label) JMPK(BPF_JGE, 1, (input), (label))
// If-less-than-or-equal-to
#define IFLE(input, label) JMPK(BPF_JGT, 1, (input), (label))
// labels are integers so they must be predefined
int success = 1;
int fail = 2;
int unmaskOnly = 3;
int isworking = 4;
int socket_setip = 5;
int ioctl_setip = 6;
uint32_t auditArch = ArchInfo_getAuditArch();
struct Filter seccompFilter[] = {
LOAD(offsetof(struct seccomp_data, arch)),
IFNE(auditArch, fail),
// Get the syscall num.
LOAD(offsetof(struct seccomp_data, nr)),
// udp
#ifdef __NR_sendmsg
IFEQ(__NR_sendmsg, success),
#endif
#ifdef __NR_recvmsg
IFEQ(__NR_recvmsg, success),
#endif
// ETHInterface
#ifdef __NR_sendto
IFEQ(__NR_sendto, success),
#endif
#ifdef __NR_recvfrom
IFEQ(__NR_recvfrom, success),
#endif
#ifdef __NR_socketcall
// 32-bit: recvmsg is a socketcall
IFEQ(__NR_socketcall, success),
#endif
// libuv
IFEQ(__NR_epoll_ctl, success),
#ifdef __NR_epoll_wait
IFEQ(__NR_epoll_wait, success),
#endif
#ifdef __NR_epoll_pwait
IFEQ(__NR_epoll_pwait, success),
#endif
// gettimeofday is required on some architectures
#ifdef __NR_gettimeofday
IFEQ(__NR_gettimeofday, success),
#endif
// TUN (and logging)
IFEQ(__NR_write, success),
IFEQ(__NR_read, success),
// readv and writev are used by some libc (musl)
#ifdef __NR_readv
IFEQ(__NR_readv, success),
#endif
#ifdef __NR_writev
IFEQ(__NR_writev, success),
#endif
// modern librt reads a read-only mapped section of kernel space which contains the time
// older versions need system calls for getting the time.
// i686 glibc-2.18's time() uses __NR_time
// Raspberry Pi and BeagleBone Black don't provide __NR_time
IFEQ(__NR_clock_gettime, success),
#ifdef __NR_time
IFEQ(__NR_time, success),
#endif
// malloc()
IFEQ(__NR_brk, success),
// abort()
IFEQ(__NR_gettid, success),
IFEQ(__NR_tgkill, success),
IFEQ(__NR_rt_sigprocmask, unmaskOnly),
// exit()
IFEQ(__NR_exit_group, success),
// Seccomp_isWorking()
IFEQ(__NR_getpriority, isworking),
// Securiy_checkPermissions() -> canOpenFiles()
IFEQ(__NR_dup, success),
IFEQ(__NR_close, success),
// Security_checkPermissions() -> getMaxMem()
// x86/ARM use ugetrlimit and mmap2
// ARM does not even have __NR_getrlimit or __NR_mmap defined
// and AMD64 does not have __NR_ugetrlimit or __NR_mmap2 defined
#ifdef __NR_getrlimit
IFEQ(__NR_getrlimit, success),
#endif
#ifdef __NR_ugetrlimit
IFEQ(__NR_ugetrlimit, success),
#endif
#ifdef __NR_mmap
IFEQ(__NR_mmap, success),
#endif
#ifdef __NR_mmap2
IFEQ(__NR_mmap2, success),
#endif
IFEQ(__NR_munmap, success),
// printf()
IFEQ(__NR_fstat, success),
#ifdef __NR_fstat64
IFEQ(__NR_fstat64, success),
#endif
// for setting IP addresses...
// socketForIfName()
#ifdef __NR_socket
IFEQ(__NR_socket, socket_setip),
#endif
IFEQ(__NR_ioctl, ioctl_setip),
RET(SECCOMP_RET_TRAP),
LABEL(socket_setip),
LOAD(offsetof(struct seccomp_data, args[1])),
IFEQ(SOCK_DGRAM, success),
RET(SECCOMP_RET_TRAP),
LABEL(ioctl_setip),
LOAD(offsetof(struct seccomp_data, args[1])),
IFEQ(SIOCGIFINDEX, success),
IFEQ(SIOCGIFFLAGS, success),
IFEQ(SIOCSIFFLAGS, success),
IFEQ(SIOCSIFADDR, success),
IFEQ(SIOCSIFNETMASK, success),
IFEQ(SIOCSIFMTU, success),
RET(SECCOMP_RET_TRAP),
// We allow sigprocmask to *unmask* signals but we don't allow it to mask them.
LABEL(unmaskOnly),
LOAD(offsetof(struct seccomp_data, args[0])),
IFEQ(SIG_UNBLOCK, success),
RET(SECCOMP_RET_TRAP),
LABEL(isworking),
RET(RET_ERRNO(IS_WORKING_ERRNO)),
LABEL(fail),
RET(SECCOMP_RET_TRAP),
LABEL(success),
RET(SECCOMP_RET_ALLOW),
};
return compile(seccompFilter, sizeof(seccompFilter)/sizeof(seccompFilter[0]), alloc);
}
int main(int argc, const char** argv){
if ( argc < 2 ) {
usage();
return -1;
}
//Script file name
const char* filename = argv[1];
//Intro on v8 Handles:
//There are two types of Handles: Persistent, and Local. Local goes onto a "stack" which is always the last
// v8::HandleScope to be created. When each HandleScope goes out of scope, it reaps the references of all the local
// variables on its "stack".
// There are two ways to pass a JS reference outside of a v8::HandleScope. One is usually used when returning from a function
// like so: return handle_scope.Close(local);. This passes the reference up to the next v8::HandleScope.
// The second way is to use another type of Handle: the Persistent Handle. This reference will not be reaped with RIIA, but will
// instead only be reaped when Dispose is called on the handle.
// v8::Handle is a superclass to both Persistent, and to Local, and can refere to either.
//This will hold the v8 context, all execution in v8 happens in such a "context"
//Note: this is a Persistent handle, which means that once initialized, its reference will not be
// reaped until we explicitly call Persistent::Dispose(). However, for now it is empty.
v8::Persistent<v8::Context> m_v8Context;
{
//All execution in v8 must happen while one of these is on the stack somewhere
v8::Locker locker;
//When this destructs, it will collect any scoped (non-persistent) Handles created from now until the end of the scope,
// reaping the Handles' references.
v8::HandleScope handle_scope;
//Greate a object tempalte, which will be a template for the global object.
v8::Handle<v8::ObjectTemplate> globt = v8::ObjectTemplate::New();
//Global template
{
//This object template will have a .log() function
//Very simple to bind simple global functions that take JS type arguments
globt->Set( v8::String::New("log"), v8::FunctionTemplate::New(LogCallback));
}
//Create the new context. v8::Context::New() returns a persistent handle. Remember to call Dispose() when we are done with it.
// We create the new context with the global template object, thus the global object of the context will not
// be copied from the global template object.
m_v8Context = v8::Context::New(NULL, globt);
//In order to do any execution within a context, we must lock it sort of.
v8::Context::Scope context_scope(m_v8Context);
//Setup the v8 context for execution
{
//Get the global object
v8::Handle<v8::Object> global = m_v8Context->Global();
//inform v8 of these classes
{
//Vector
juice::ogre::Vector::bind(global);
}
}
} //Leave the setup scope
//Compile and run a script
//This can be anywhere, we left all the scopes.
{
//We are about to do some v8 stuff ... lock it.
v8::Locker locker;
//Create a stack for Local handles.
v8::HandleScope handle_scope;
//Lock the context for execution
v8::Context::Scope context_scope(m_v8Context);
//Simply use this utility function to read in the file to a strings.
v8::Handle<v8::String> script_source = ReadFile(filename);
//Sanity
if (script_source.IsEmpty()) {
printf("Failed to load file.\n");
return -1;
}
//Use the compile function above to return a compiled script.
v8::Handle<v8::Script> script = compile(script_source,
v8::String::New(filename),
//Report errors with the utility function object above
// std::bind simply creates a stl function object out of a function.
// The function object will take one argument, the exception, and we predefine
// its second argument, which is a stream out for error messages, as going to
// std::cout.
boost::bind(ReportException<std::ostream>, _1, boost::ref(std::cout)));
//Sanity
if ( script.IsEmpty() )
{
printf("Failed to compile script.\n");
return -1;
}
//Use the utility run function to run the script.
v8::Handle<v8::Value> result = run(script,
//See explanation by complile() above, this function object
// will report exception errors to std::cout.
boost::bind(ReportException<std::ostream>, _1, boost::ref(std::cout)) );
}// leave locks, scopes etc.
// We are no longer going to use the context. Dispose of it.
m_v8Context.Dispose();
return 0;
};
void
kdb5_update_princ_encryption(int argc, char *argv[])
{
struct update_enc_mkvno data = { 0 };
char *name_pattern = NULL;
int force = 0;
int optchar;
krb5_error_code retval;
krb5_actkvno_node *actkvno_list = 0;
krb5_db_entry *master_entry;
char *mkey_fullname = 0;
#ifdef BSD_REGEXPS
char *msg;
#endif
char *regexp = NULL;
krb5_keyblock *act_mkey;
krb5_keylist_node *master_keylist = krb5_db_mkey_list_alias(util_context);
while ((optchar = getopt(argc, argv, "fnv")) != -1) {
switch (optchar) {
case 'f':
force = 1;
break;
case 'n':
data.dry_run = 1;
break;
case 'v':
data.verbose = 1;
break;
case '?':
case ':':
default:
usage();
}
}
if (argv[optind] != NULL) {
name_pattern = argv[optind];
if (argv[optind+1] != NULL)
usage();
}
retval = krb5_unparse_name(util_context, master_princ, &mkey_fullname);
if (retval) {
com_err(progname, retval, _("while formatting master principal name"));
exit_status++;
goto cleanup;
}
if (master_keylist == NULL) {
com_err(progname, retval, _("master keylist not initialized"));
exit_status++;
goto cleanup;
}
/* The glob_to_regexp code only cares if the "realm" parameter is
NULL or not; the string data is irrelevant. */
if (name_pattern == NULL)
name_pattern = "*";
if (glob_to_regexp(name_pattern, "hi", ®exp) != 0) {
com_err(progname, ENOMEM,
_("converting glob pattern '%s' to regular expression"),
name_pattern);
exit_status++;
goto cleanup;
}
if (
#ifdef SOLARIS_REGEXPS
((data.expbuf = compile(regexp, NULL, NULL)) == NULL)
#endif
#ifdef POSIX_REGEXPS
((regcomp(&data.preg, regexp, REG_NOSUB)) != 0)
#endif
#ifdef BSD_REGEXPS
((msg = (char *) re_comp(regexp)) != NULL)
#endif
) {
/* XXX syslog msg or regerr(regerrno) */
com_err(progname, 0, _("error compiling converted regexp '%s'"),
regexp);
exit_status++;
goto cleanup;
}
retval = krb5_db_get_principal(util_context, master_princ, 0,
&master_entry);
if (retval != 0) {
com_err(progname, retval, _("while getting master key principal %s"),
mkey_fullname);
exit_status++;
goto cleanup;
}
retval = krb5_dbe_lookup_actkvno(util_context, master_entry, &actkvno_list);
if (retval != 0) {
com_err(progname, retval, _("while looking up active kvno list"));
exit_status++;
goto cleanup;
}
retval = krb5_dbe_find_act_mkey(util_context, actkvno_list, &new_mkvno,
&act_mkey);
if (retval) {
com_err(progname, retval, _("while looking up active master key"));
exit_status++;
goto cleanup;
}
new_master_keyblock = *act_mkey;
if (!force &&
!data.dry_run &&
!are_you_sure(_("Re-encrypt all keys not using master key vno %u?"),
new_mkvno)) {
printf(_("OK, doing nothing.\n"));
exit_status++;
goto cleanup;
}
if (data.verbose) {
if (data.dry_run) {
printf(_("Principals whose keys WOULD BE re-encrypted to master "
"key vno %u:\n"), new_mkvno);
} else {
printf(_("Principals whose keys are being re-encrypted to master "
"key vno %u if necessary:\n"), new_mkvno);
}
}
if (!data.dry_run) {
/* Grab a write lock so we don't have to upgrade to a write lock and
* reopen the DB while iterating. */
retval = krb5_db_lock(util_context, KRB5_DB_LOCKMODE_EXCLUSIVE);
if (retval != 0 && retval != KRB5_PLUGIN_OP_NOTSUPP) {
com_err(progname, retval, _("trying to lock database"));
exit_status++;
}
}
retval = krb5_db_iterate(util_context, name_pattern,
update_princ_encryption_1, &data);
/* If exit_status is set, then update_princ_encryption_1 already
printed a message. */
if (retval != 0 && exit_status == 0) {
com_err(progname, retval, _("trying to process principal database"));
exit_status++;
}
if (!data.dry_run)
(void)krb5_db_unlock(util_context);
(void) krb5_db_fini(util_context);
if (data.dry_run) {
printf(_("%u principals processed: %u would be updated, %u already "
"current\n"),
data.re_match_count, data.updated, data.already_current);
} else {
printf(_("%u principals processed: %u updated, %u already current\n"),
data.re_match_count, data.updated, data.already_current);
}
cleanup:
free(regexp);
memset(&new_master_keyblock, 0, sizeof(new_master_keyblock));
krb5_free_unparsed_name(util_context, mkey_fullname);
krb5_dbe_free_actkvno_list(util_context, actkvno_list);
}
void CompositorScriptCompilerTests::testCompile()
{
if (!ResourceGroupManager::getSingletonPtr())
new ResourceGroupManager();
if (!MaterialManager::getSingletonPtr())
{
new MaterialManager();
MaterialManager::getSingleton().initialise();
}
if (!CompositorManager::getSingletonPtr())
new CompositorManager();
//compositorMgr->initialise();
const String simpleScript = "compositor \"First Test\" { technique { target_output { } } }";
CPPUNIT_ASSERT(compile(simpleScript, "Test Compositor"));
const String BW_Script =
"/// Black and white effect \n"
"compositor B&W \n"
"{ \n"
" technique \n"
" { \n"
" // Temporary textures \n"
" texture scene target_width target_height PF_A8R8G8B8 \n"
" \n"
" target scene \n"
" { \n"
" // Render output from previous compositor (or original scene) \n"
" input previous \n"
" }"
" target_output \n"
" { \n"
" // Start with clear output \n"
" input none \n"
" // Draw a fullscreen quad with the blur \n"
" pass render_quad \n"
" { \n"
" // Renders a fullscreen quad with a material \n"
" material PostFilters/BlackAndWhite \n"
" input 0 scene \n"
" } \n"
" } \n"
" } \n"
"} \n";
CPPUNIT_ASSERT(compile(BW_Script, "Test Black & White Script"));
const String Bloom_Script =
"/// Manuel's bloom \n"
"/// Needs a scene-sized rtt, but does only one render of the scene \n"
"compositor Bloom \n"
"{ \n"
" technique \n"
" { \n"
" // Temporary textures \n"
" texture scene target_width target_height PF_A8R8G8B8 \n"
" texture rt0 128 128 PF_A8R8G8B8 \n"
" texture rt1 128 128 PF_A8R8G8B8 \n"
" \n"
" target scene \n"
" { \n"
" // Render output from previous compositor (or original scene) \n"
" input previous \n"
" } \n"
" target rt0 \n"
" { \n"
" // Start with clear texture \n"
" input none \n"
" // Vertical blur pass \n"
" pass render_quad \n"
" { \n"
" // Renders a fullscreen quad with a material \n"
" material PostFilters/Blur0 \n"
" input 0 scene \n"
" } \n"
" } \n"
" target rt1 \n"
" { \n"
" // Start with clear texture \n"
" input none \n"
" // Horizontal blur pass \n"
" pass render_quad \n"
" { \n"
" // Renders a fullscreen quad with a material \n"
" material PostFilters/Blur1 \n"
" input 0 rt0 \n"
" } \n"
" } \n"
" target_output \n"
" { \n"
" // Start with clear output \n"
" input none \n"
" // Draw a fullscreen quad \n"
" pass render_quad \n"
" { \n"
" // Renders a fullscreen quad with a material \n"
" material PostFilters/BloomBlend \n"
" input 0 scene \n"
" input 1 rt1 \n"
" } \n"
" } \n"
" } \n"
"} \n";
CPPUNIT_ASSERT(compile(Bloom_Script, "Test Bloom Script"));
}
// Handle the back branch event. Notice that we can compile the method
// with a regular entry from here.
void AdvancedThresholdPolicy::method_back_branch_event(methodHandle mh, methodHandle imh,
int bci, CompLevel level, nmethod* nm, JavaThread* thread) {
if (should_create_mdo(mh(), level)) {
create_mdo(mh, thread);
}
// Check if MDO should be created for the inlined method
if (should_create_mdo(imh(), level)) {
create_mdo(imh, thread);
}
if (is_compilation_enabled()) {
CompLevel next_osr_level = loop_event(imh(), level);
CompLevel max_osr_level = (CompLevel)imh->highest_osr_comp_level();
// At the very least compile the OSR version
if (!CompileBroker::compilation_is_in_queue(imh) && (next_osr_level != level)) {
compile(imh, bci, next_osr_level, thread);
}
// Use loop event as an opportunity to also check if there's been
// enough calls.
CompLevel cur_level, next_level;
if (mh() != imh()) { // If there is an enclosing method
guarantee(nm != NULL, "Should have nmethod here");
cur_level = comp_level(mh());
next_level = call_event(mh(), cur_level);
if (max_osr_level == CompLevel_full_optimization) {
// The inlinee OSRed to full opt, we need to modify the enclosing method to avoid deopts
bool make_not_entrant = false;
if (nm->is_osr_method()) {
// This is an osr method, just make it not entrant and recompile later if needed
make_not_entrant = true;
} else {
if (next_level != CompLevel_full_optimization) {
// next_level is not full opt, so we need to recompile the
// enclosing method without the inlinee
cur_level = CompLevel_none;
make_not_entrant = true;
}
}
if (make_not_entrant) {
if (PrintTieredEvents) {
int osr_bci = nm->is_osr_method() ? nm->osr_entry_bci() : InvocationEntryBci;
print_event(MAKE_NOT_ENTRANT, mh(), mh(), osr_bci, level);
}
nm->make_not_entrant();
}
}
if (!CompileBroker::compilation_is_in_queue(mh)) {
// Fix up next_level if necessary to avoid deopts
if (next_level == CompLevel_limited_profile && max_osr_level == CompLevel_full_profile) {
next_level = CompLevel_full_profile;
}
if (cur_level != next_level) {
compile(mh, InvocationEntryBci, next_level, thread);
}
}
} else {
cur_level = comp_level(imh());
next_level = call_event(imh(), cur_level);
if (!CompileBroker::compilation_is_in_queue(imh) && (next_level != cur_level)) {
compile(imh, InvocationEntryBci, next_level, thread);
}
}
}
}
void kit::BakedTerrain::updateGpuProgram()
{
if(!m_valid)
{
return;
}
// Generate vertexshader sourcecode
std::stringstream vertexSource;
{
// Header
vertexSource << "#version 410 core" << std::endl;
vertexSource << std::endl;
// In attributes
vertexSource << "layout (location = 0) in vec3 in_position;" << std::endl;
vertexSource << "layout (location = 1) in vec2 in_texcoord;" << std::endl;
vertexSource << "layout (location = 2) in vec3 in_normal;" << std::endl;
vertexSource << "layout (location = 3) in vec3 in_tangent;" << std::endl;
vertexSource << "layout (location = 4) in vec3 in_bitangent;" << std::endl;
vertexSource << std::endl;
// Out attributes
vertexSource << "layout (location = 0) out vec2 out_texcoord;" << std::endl;
vertexSource << "layout (location = 1) out vec3 out_normal;" << std::endl;
vertexSource << "layout (location = 2) out vec3 out_tangent;" << std::endl;
vertexSource << "layout (location = 3) out vec3 out_bitangent;" << std::endl;
vertexSource << "layout (location = 4) out vec4 out_position;" << std::endl;
vertexSource << std::endl;
// Uniforms
vertexSource << "uniform mat4 uniform_mvpMatrix;" << std::endl;
vertexSource << "uniform mat4 uniform_mvMatrix;" << std::endl;
vertexSource << std::endl;
// ---- Main code begins ---- //
vertexSource << "void main()" << std::endl;
vertexSource << "{" << std::endl;
// Prepare variables
vertexSource << " vec4 position = vec4(in_position, 1.0);" << std::endl;
vertexSource << std::endl;
// Write attributes
vertexSource << " out_position = uniform_mvMatrix * position;" << std::endl;
vertexSource << " out_normal = (uniform_mvMatrix * vec4(normalize(in_normal), 0.0)).xyz;" << std::endl;
vertexSource << " out_texcoord = in_texcoord;" << std::endl;
vertexSource << " out_tangent = (uniform_mvMatrix * vec4(normalize(in_tangent), 0.0)).xyz;" << std::endl;
vertexSource << " out_bitangent = (uniform_mvMatrix * vec4(normalize(in_bitangent), 0.0)).xyz;" << std::endl;
vertexSource << std::endl;
// Write gl_* variables
vertexSource << " gl_Position = uniform_mvpMatrix * position;" << std::endl;
// ---- Main code ends ---- //
vertexSource << "}" << std::endl;
}
// Generate pixelshader sourcecode
std::stringstream pixelSource;
{
// Header
pixelSource << "#version 410 core" << std::endl;
pixelSource << std::endl;
// In attributes
pixelSource << "layout (location = 0) in vec2 in_texCoords;" << std::endl;
pixelSource << "layout (location = 1) in vec3 in_normal;" << std::endl;
pixelSource << "layout (location = 2) in vec3 in_tangent;" << std::endl;
pixelSource << "layout (location = 3) in vec3 in_bitangent;" << std::endl;
pixelSource << "layout (location = 4) in vec4 in_position;" << std::endl;
pixelSource << std::endl;
// Out attributes
pixelSource << "layout (location = 0) out vec4 out_A;" << std::endl;
pixelSource << "layout (location = 1) out vec4 out_B;" << std::endl;
pixelSource << "layout (location = 2) out vec4 out_C;" << std::endl;
pixelSource << "layout (location = 3) out vec4 out_D;" << std::endl;
// Function to blend two textures smoothly based on a depthmap
pixelSource << "vec4 blend2(vec4 below, vec4 above, float a2)" << std::endl;
pixelSource << "{" << std::endl;
pixelSource << " float depth = 0.1;" << std::endl;
pixelSource << std::endl;
pixelSource << " float f1 = 1.1;" << std::endl;
pixelSource << " float f2 = a2;" << std::endl;
pixelSource << " float ma = max(f1, f2) - depth;" << std::endl;
pixelSource << std::endl;
pixelSource << " float b1 = max(f1 - ma, 0);" << std::endl;
pixelSource << " float b2 = max(f2 - ma, 0);" << std::endl;
pixelSource << std::endl;
pixelSource << " return (below.rgba * b1 + above.rgba * b2) / (b1 + b2);" << std::endl;
pixelSource << "}" << std::endl;
pixelSource << std::endl;
// Uniforms
if (m_numLayers > 1)
{
pixelSource << "uniform sampler2D uniform_materialMask0;" << std::endl;
}
if (m_numLayers > 4)
{
pixelSource << "uniform sampler2D uniform_materialMask1;" << std::endl;
}
pixelSource << "uniform sampler2D uniform_arCache;" << std::endl;
pixelSource << "uniform sampler2D uniform_nxCache;" << std::endl;
pixelSource << "uniform float uniform_detailDistance;" << std::endl;
pixelSource << std::endl;
// Layerspecific uniforms
for(int i = 0; i < m_numLayers; i++)
{
pixelSource << "uniform sampler2D uniform_arLayer" << i << ";" << std::endl;
pixelSource << "uniform sampler2D uniform_ndLayer" << i << ";" << std::endl;
pixelSource << std::endl;
}
// ---- Main code begins ---- //
pixelSource << "void main()" << std::endl;
pixelSource << "{" << std::endl;
// Prepare variables
pixelSource << " vec2 fullUv = in_texCoords;" << std::endl;
pixelSource << " vec2 detailUv = in_texCoords * vec2(" << (float)m_size.x * m_xzScale << ", " << (float)m_size.y * m_xzScale << ");" << std::endl;
pixelSource << " float linearDistance = distance(vec3(0.0), in_position.xyz / in_position.w);" << std::endl;
// Prepare output variables
pixelSource << " vec4 arOut; " << std::endl;
pixelSource << " vec3 nOut;" << std::endl;
// If the distance to the fragment is higher than the detail distance, output the cached AR and NM maps
pixelSource << " if (linearDistance > uniform_detailDistance)" << std::endl;
pixelSource << " {" << std::endl;
pixelSource << " arOut = texture(uniform_arCache, fullUv);" << std::endl;
pixelSource << " nOut = texture(uniform_nxCache, fullUv).rgb;" << std::endl;
pixelSource << " }" << std::endl;
// Otherwise, do some magic
pixelSource << " else" << std::endl;
pixelSource << " {" << std::endl;
// Sample the materialmasks
if (m_numLayers > 1)
{
pixelSource << " vec4 materialMask0 = texture(uniform_materialMask0, fullUv);" << std::endl;
}
if (m_numLayers > 4)
{
pixelSource << " vec4 materialMask1 = texture(uniform_materialMask1, fullUv);" << std::endl;
}
// Sample the layer maps
for (int i = 0; i < m_numLayers; i++)
{
pixelSource << " vec4 ar" << i << " = texture(uniform_arLayer" << i << ", detailUv * " << m_layerInfo[i].uvScale << ");" << std::endl;
pixelSource << " vec4 nd" << i << " = texture(uniform_ndLayer" << i << ", detailUv * " << m_layerInfo[i].uvScale << ");" << std::endl;
if (i == 0)
{
pixelSource << " arOut = ar0;" << std::endl;
pixelSource << " nOut = nd0.rgb;" << std::endl;
}
else
{
pixelSource << " arOut = blend2(arOut, ar" << i << ", materialMask" << getMaskSuffix(i) << " + nd" << i << ".a);" << std::endl;
pixelSource << " nOut = blend2(vec4(nOut, 0.0), vec4(nd" << i << ".rgb, 0.0), materialMask" << getMaskSuffix(i) << " + nd" << i << ".a).rgb;" << std::endl;
}
}
// We're done with generating output
pixelSource << " }" << std::endl;
pixelSource << std::endl;
// Prepare normalmapping and output
pixelSource << " mat3 normalRotation= (mat3(normalize(in_tangent), normalize(in_bitangent), normalize(in_normal)));" << std::endl;
pixelSource << " vec3 normalTex = normalize((nOut.rgb - 0.5)*2.0);" << std::endl;
pixelSource << " vec3 normal = normalize(normalRotation * normalTex);" << std::endl;
// Write output
pixelSource << " out_A = arOut;" << std::endl;
pixelSource << " out_B = vec4(0.0, 0.0, 0.0, 0.0);" << std::endl;
pixelSource << " out_C.xyz = normal;" << std::endl;
pixelSource << " out_C.a = 1.0;" << std::endl;
// Mission complete!
pixelSource << "}" << std::endl;
}
// Compile shader objects
auto vertexShader = new kit::Shader(Shader::Type::Vertex);
vertexShader->sourceFromString(vertexSource.str());
vertexShader->compile();
auto pixelShader = new kit::Shader(Shader::Type::Fragment);
pixelShader->sourceFromString(pixelSource.str());
pixelShader->compile();
// Link program
if(m_program)
delete m_program;
m_program = new kit::Program();
m_program->attachShader(vertexShader);
m_program->attachShader(pixelShader);
m_program->link();
m_program->detachShader(vertexShader);
m_program->detachShader(pixelShader);
delete vertexShader;
delete pixelShader;
// Update uniforms
if (m_numLayers > 1)
{
m_program->setUniformTexture("uniform_materialMask0", m_materialMask[0]);
}
if (m_numLayers > 4)
{
m_program->setUniformTexture("uniform_materialMask1", m_materialMask[1]);
}
m_program->setUniformTexture("uniform_arCache", m_arCache);
m_program->setUniformTexture("uniform_nxCache", m_nxCache);
m_program->setUniform1f("uniform_detailDistance", 500.0f); //< TODO: Replace with configuration parameter
// Layer-specific uniforms
for(int i = 0; i < m_numLayers; i++)
{
m_program->setUniformTexture("uniform_arLayer" + std::to_string(i), m_layerInfo[i].arCache);
m_program->setUniformTexture("uniform_ndLayer" + std::to_string(i), m_layerInfo[i].ndCache);
}
}
ComputeShaderInstance::ComputeShaderInstance(const Shader<ComputeShader> *ker) : ShaderInstanceBase(), kernel(ker) {
const ShaderBase *b = static_cast<const ShaderBase *>(kernel);
compile(&b, 1);
}
