const std::string Tag::Translate(const Directives& directives) {
switch (type) {
case VERBATIM:
return value;
case PRIMARY_HANDLE:
return directives.TranslateTagHandle("!") + value;
case SECONDARY_HANDLE:
return directives.TranslateTagHandle("!!") + value;
case NAMED_HANDLE:
return directives.TranslateTagHandle("!" + handle + "!") + value;
case NON_SPECIFIC:
// TODO:
return "!";
default:
assert(false);
}
throw std::runtime_error("yaml-cpp: internal error, bad tag type");
}
void
BinObject::AddDirectives(Directives& dirs, llvm::StringRef parser)
{
static const Directives::Init<BinObject> nasm_dirs[] =
{
{"section", &BinObject::DirSection, Directives::ARG_REQUIRED},
{"segment", &BinObject::DirSection, Directives::ARG_REQUIRED},
{"org", &BinObject::DirOrg, Directives::ARG_REQUIRED},
{"map", &BinObject::DirMap, Directives::ANY},
};
static const Directives::Init<BinObject> gas_dirs[] =
{
{".section", &BinObject::DirSection, Directives::ARG_REQUIRED},
};
if (parser.equals_lower("nasm"))
dirs.AddArray(this, nasm_dirs);
else if (parser.equals_lower("gas") || parser.equals_lower("gnu"))
dirs.AddArray(this, gas_dirs);
}
int main()
{
struct sockaddr_in sockinfo;
t_socket sock;
ModuleInfos * moduleInfos = get_module_infos();
Directives * moduleDirectives = get_directives();
// std::cout << moduleInfos->associatedDLL << std::endl;
// std::cout << moduleInfos->name << std::endl;
std::string req(
"GET /index.php?toto=tutu&tata=titi HTTP/1.0\n"
"Host: example.com\n"
"Referer: http://example.com/\n"
"User-Agent: CERN-LineMode/2.15 libwww/2.17b3\n"
);
int size = req.size();
char *buff = new char[size];
req.copy(buff, size);
Request request(buff, size);
Response response(NULL, 0);
request.separate();
moduleDirectives->init();
moduleDirectives->callDirective(CREATE_RESPONSE, request, response, sock, sockinfo);
response.assemble();
std::string out;
out.append(response.getBuffer(), response.getLength());
std::cout << out << std::endl;
delete moduleDirectives;
delete moduleInfos;
return 0;
}
void
XdfObject::AddDirectives(Directives& dirs, llvm::StringRef parser)
{
static const Directives::Init<XdfObject> nasm_dirs[] =
{
{"section", &XdfObject::DirSection, Directives::ARG_REQUIRED},
{"segment", &XdfObject::DirSection, Directives::ARG_REQUIRED},
};
if (parser.equals_lower("nasm"))
dirs.AddArray(this, nasm_dirs);
}
void
Win64Object::AddDirectives(Directives& dirs, llvm::StringRef parser)
{
static const Directives::Init<Win64Object> gas_dirs[] =
{
{".export", &Win64Object::DirExport, Directives::ID_REQUIRED},
{".proc_frame", &Win64Object::DirProcFrame, Directives::ID_REQUIRED},
{".pushreg", &Win64Object::DirPushReg, Directives::ARG_REQUIRED},
{".setframe", &Win64Object::DirSetFrame, Directives::ARG_REQUIRED},
{".allocstack", &Win64Object::DirAllocStack, Directives::ARG_REQUIRED},
{".savereg", &Win64Object::DirSaveReg, Directives::ARG_REQUIRED},
{".savexmm128", &Win64Object::DirSaveXMM128, Directives::ARG_REQUIRED},
{".pushframe", &Win64Object::DirPushFrame, Directives::ANY},
{".endprolog", &Win64Object::DirEndProlog, Directives::ANY},
{".endproc_frame", &Win64Object::DirEndProcFrame, Directives::ANY},
};
static const Directives::Init<Win64Object> nasm_dirs[] =
{
{"export", &Win64Object::DirExport, Directives::ID_REQUIRED},
{"proc_frame", &Win64Object::DirProcFrame, Directives::ID_REQUIRED},
{"pushreg", &Win64Object::DirPushReg, Directives::ARG_REQUIRED},
{"setframe", &Win64Object::DirSetFrame, Directives::ARG_REQUIRED},
{"allocstack", &Win64Object::DirAllocStack, Directives::ARG_REQUIRED},
{"savereg", &Win64Object::DirSaveReg, Directives::ARG_REQUIRED},
{"savexmm128", &Win64Object::DirSaveXMM128, Directives::ARG_REQUIRED},
{"pushframe", &Win64Object::DirPushFrame, Directives::ANY},
{"endprolog", &Win64Object::DirEndProlog, Directives::ANY},
{"endproc_frame", &Win64Object::DirEndProcFrame, Directives::ANY},
};
if (parser.equals_lower("nasm"))
dirs.AddArray(this, nasm_dirs);
else if (parser.equals_lower("gas") || parser.equals_lower("gnu"))
dirs.AddArray(this, gas_dirs);
// Pull in coff directives (but not win32 directives)
CoffObject::AddDirectives(dirs, parser);
}
// Compile a JS function body, which might appear as the value of an event
// handler attribute in an HTML <INPUT> tag, or in a Function() constructor.
bool
frontend::CompileFunctionBody(JSContext *cx, MutableHandleFunction fun, CompileOptions options,
const AutoNameVector &formals, const jschar *chars, size_t length)
{
// FIXME: make Function pass in two strings and parse them as arguments and
// ProgramElements respectively.
SkipRoot skip(cx, &chars);
MaybeCallSourceHandler(cx, options, chars, length);
if (!CheckLength(cx, length))
return false;
ScriptSource *ss = cx->new_<ScriptSource>(options.originPrincipals());
if (!ss)
return false;
if (options.filename && !ss->setFilename(cx, options.filename))
return false;
JS::RootedScriptSource sourceObject(cx, ScriptSourceObject::create(cx, ss));
if (!sourceObject)
return false;
SourceCompressionToken sct(cx);
JS_ASSERT(options.sourcePolicy != CompileOptions::LAZY_SOURCE);
if (options.sourcePolicy == CompileOptions::SAVE_SOURCE) {
if (!ss->setSourceCopy(cx, chars, length, true, &sct))
return false;
}
bool canLazilyParse = CanLazilyParse(cx, options);
Maybe<Parser<SyntaxParseHandler> > syntaxParser;
if (canLazilyParse) {
syntaxParser.construct(cx, &cx->tempLifoAlloc(),
options, chars, length, /* foldConstants = */ false,
(Parser<SyntaxParseHandler> *) NULL,
(LazyScript *) NULL);
}
JS_ASSERT(!options.forEval);
Parser<FullParseHandler> parser(cx, &cx->tempLifoAlloc(),
options, chars, length, /* foldConstants = */ true,
canLazilyParse ? &syntaxParser.ref() : NULL, NULL);
parser.sct = &sct;
parser.ss = ss;
JS_ASSERT(fun);
JS_ASSERT(fun->isTenured());
fun->setArgCount(formals.length());
// Speculatively parse using the default directives implied by the context.
// If a directive is encountered (e.g., "use strict") that changes how the
// function should have been parsed, we backup and reparse with the new set
// of directives.
Directives directives(options.strictOption);
TokenStream::Position start(parser.keepAtoms);
parser.tokenStream.tell(&start);
ParseNode *fn;
while (true) {
Directives newDirectives = directives;
fn = parser.standaloneFunctionBody(fun, formals, directives, &newDirectives);
if (fn)
break;
if (parser.hadAbortedSyntaxParse()) {
// Hit some unrecoverable ambiguity during an inner syntax parse.
// Syntax parsing has now been disabled in the parser, so retry
// the parse.
parser.clearAbortedSyntaxParse();
} else {
if (parser.tokenStream.hadError() || directives == newDirectives)
return false;
// Assignment must be monotonic to prevent reparsing iloops
JS_ASSERT_IF(directives.strict(), newDirectives.strict());
JS_ASSERT_IF(directives.asmJS(), newDirectives.asmJS());
directives = newDirectives;
}
parser.tokenStream.seek(start);
}
if (!NameFunctions(cx, fn))
return false;
if (fn->pn_funbox->function()->isInterpreted()) {
JS_ASSERT(fun == fn->pn_funbox->function());
Rooted<JSScript*> script(cx, JSScript::Create(cx, NullPtr(), false, options,
/* staticLevel = */ 0, sourceObject,
/* sourceStart = */ 0, length));
if (!script)
return false;
script->bindings = fn->pn_funbox->bindings;
/*
* The reason for checking fun->environment() below is that certain
* consumers of JS::CompileFunction, namely
* nsEventListenerManager::CompileEventHandlerInternal, passes in a
* NULL environment. This compiled function is never used, but instead
* is cloned immediately onto the right scope chain.
*/
BytecodeEmitter funbce(/* parent = */ NULL, &parser, fn->pn_funbox, script,
/* insideEval = */ false, /* evalCaller = */ NullPtr(),
fun->environment() && fun->environment()->is<GlobalObject>(),
options.lineno);
if (!funbce.init())
return false;
if (!EmitFunctionScript(cx, &funbce, fn->pn_body))
return false;
} else {
fun.set(fn->pn_funbox->function());
JS_ASSERT(IsAsmJSModuleNative(fun->native()));
}
if (!SetSourceMap(cx, parser.tokenStream, ss))
return false;
if (!sct.complete())
return false;
return true;
}
// Compile a JS function body, which might appear as the value of an event
// handler attribute in an HTML <INPUT> tag, or in a Function() constructor.
static bool
CompileFunctionBody(JSContext *cx, MutableHandleFunction fun, const ReadOnlyCompileOptions &options,
const AutoNameVector &formals, SourceBufferHolder &srcBuf,
HandleObject enclosingScope, GeneratorKind generatorKind)
{
js::TraceLogger *logger = js::TraceLoggerForMainThread(cx->runtime());
uint32_t logId = js::TraceLogCreateTextId(logger, options);
js::AutoTraceLog scriptLogger(logger, logId);
js::AutoTraceLog typeLogger(logger, TraceLogger::ParserCompileFunction);
// FIXME: make Function pass in two strings and parse them as arguments and
// ProgramElements respectively.
if (!CheckLength(cx, srcBuf))
return false;
RootedScriptSource sourceObject(cx, CreateScriptSourceObject(cx, options));
if (!sourceObject)
return false;
ScriptSource *ss = sourceObject->source();
SourceCompressionTask sct(cx);
MOZ_ASSERT(!options.sourceIsLazy);
if (!cx->compartment()->options().discardSource()) {
if (!ss->setSourceCopy(cx, srcBuf, true, &sct))
return false;
}
bool canLazilyParse = CanLazilyParse(cx, options);
Maybe<Parser<SyntaxParseHandler> > syntaxParser;
if (canLazilyParse) {
syntaxParser.emplace(cx, &cx->tempLifoAlloc(),
options, srcBuf.get(), srcBuf.length(),
/* foldConstants = */ false,
(Parser<SyntaxParseHandler> *) nullptr,
(LazyScript *) nullptr);
}
MOZ_ASSERT(!options.forEval);
Parser<FullParseHandler> parser(cx, &cx->tempLifoAlloc(),
options, srcBuf.get(), srcBuf.length(),
/* foldConstants = */ true,
canLazilyParse ? syntaxParser.ptr() : nullptr, nullptr);
parser.sct = &sct;
parser.ss = ss;
MOZ_ASSERT(fun);
MOZ_ASSERT(fun->isTenured());
fun->setArgCount(formals.length());
// Speculatively parse using the default directives implied by the context.
// If a directive is encountered (e.g., "use strict") that changes how the
// function should have been parsed, we backup and reparse with the new set
// of directives.
Directives directives(options.strictOption);
TokenStream::Position start(parser.keepAtoms);
parser.tokenStream.tell(&start);
ParseNode *fn;
while (true) {
Directives newDirectives = directives;
fn = parser.standaloneFunctionBody(fun, formals, generatorKind, directives, &newDirectives);
if (fn)
break;
if (parser.hadAbortedSyntaxParse()) {
// Hit some unrecoverable ambiguity during an inner syntax parse.
// Syntax parsing has now been disabled in the parser, so retry
// the parse.
parser.clearAbortedSyntaxParse();
} else {
if (parser.tokenStream.hadError() || directives == newDirectives)
return false;
// Assignment must be monotonic to prevent reparsing iloops
MOZ_ASSERT_IF(directives.strict(), newDirectives.strict());
MOZ_ASSERT_IF(directives.asmJS(), newDirectives.asmJS());
directives = newDirectives;
}
parser.tokenStream.seek(start);
}
if (!NameFunctions(cx, fn))
return false;
if (!SetDisplayURL(cx, parser.tokenStream, ss))
return false;
if (!SetSourceMap(cx, parser.tokenStream, ss))
return false;
if (fn->pn_funbox->function()->isInterpreted()) {
MOZ_ASSERT(fun == fn->pn_funbox->function());
Rooted<JSScript*> script(cx, JSScript::Create(cx, enclosingScope, false, options,
/* staticLevel = */ 0, sourceObject,
/* sourceStart = */ 0, srcBuf.length()));
if (!script)
return false;
script->bindings = fn->pn_funbox->bindings;
/*
* The reason for checking fun->environment() below is that certain
* consumers of JS::CompileFunction, namely
* EventListenerManager::CompileEventHandlerInternal, passes in a
* nullptr environment. This compiled function is never used, but
* instead is cloned immediately onto the right scope chain.
*/
BytecodeEmitter funbce(/* parent = */ nullptr, &parser, fn->pn_funbox, script,
/* lazyScript = */ js::NullPtr(), /* insideEval = */ false,
/* evalCaller = */ js::NullPtr(),
fun->environment() && fun->environment()->is<GlobalObject>(),
options.lineno);
if (!funbce.init())
return false;
if (!EmitFunctionScript(cx, &funbce, fn->pn_body))
return false;
} else {
fun.set(fn->pn_funbox->function());
MOZ_ASSERT(IsAsmJSModuleNative(fun->native()));
}
if (!sct.complete())
return false;
return true;
}