queue<string> readfile(fstream &fin,parser &SLRparser)
{
char line[SIZE];
queue<string> testCases;
while(fin.getline(line,sizeof(line),'\n')){
string transfer(line);
if(!strncmp(line, "#", 1)){
}
else if(!strncmp(line, "non-term:", 9)){
SLRparser.storeNonTerminals(transfer.substr(9));
}
else if(!strncmp(line, "term:", 5)){
SLRparser.storeTerminals(transfer.substr(5));
}
else if(!strncmp(line, "prod:", 5)){
SLRparser.storeProductions(transfer.substr(5));
}
else if(!strncmp(line, "start:", 6)){
SLRparser.storeStartSymbol(transfer.substr(6));
}
else{
testCases.push(transfer);
}
}
return testCases;
}
static expr parse_notation_expr(parser & p, buffer<expr> const & locals) {
auto pos = p.pos();
expr r = p.parse_expr();
r = abstract(r, locals.size(), locals.data());
check_notation_expr(r, pos);
return r;
}
environment namespace_cmd(parser & p) {
auto pos = p.pos();
name n = p.check_atomic_id_next("invalid namespace declaration, atomic identifier expected");
if (is_root_namespace(n))
throw parser_error(sstream() << "invalid namespace name, '" << n << "' is reserved", pos);
return push_scope(p.env(), p.ios(), n);
}
inline int _parse_quadhex(parser<Iter> &in_)
{
int uni_ch = 0,
hex;
for (int i = 0; i < 4; i++)
{
if ((hex = in_.getc()) == -1)
{
return -1;
}
if ('0' <= hex && hex <= '9')
{
hex -= '0';
}
else if ('A' <= hex && hex <= 'F')
{
hex -= 'A' - 0xa;
}
else if ('a' <= hex && hex <= 'f')
{
hex -= 'a' - 0xa;
}
else
{
in_.ungetc();
return -1;
}
uni_ch = uni_ch * 16 + hex;
}
return uni_ch;
}
static name parse_quoted_symbol_or_token(parser & p, buffer<token_entry> & new_tokens, bool & used_default, notation_entry_group grp) {
used_default = false;
if (p.curr_is_quoted_symbol()) {
environment const & env = p.env();
auto pp_tk = p.get_name_val();
auto tks = utf8_trim(pp_tk.to_string());
auto tkcs = tks.c_str();
check_not_forbidden(tkcs);
p.next();
if (p.curr_is_token(get_colon_tk())) {
p.next();
unsigned prec = parse_precedence(p);
new_tokens.push_back(mk_token_entry(tkcs, prec, grp));
} else if (!get_precedence(env, tkcs, grp)) {
new_tokens.push_back(mk_token_entry(tkcs, LEAN_DEFAULT_PRECEDENCE, grp));
used_default = true;
}
return pp_tk;
} else if (p.curr_is_keyword()) {
auto tk = p.get_token_info().token();
check_not_forbidden(tk.to_string().c_str());
p.next();
return tk;
} else {
throw parser_error("invalid notation declaration, symbol expected", p.pos());
}
}
void show_usage(parser& p)
{
cout <<desc<<"\n"<<"FORMAT KEYWORDS:\n";
for (parser::parse_elements::iterator it = p.keywords_begin(); it != p.keywords_end() ; it++)
{
cout <<"\t"<<parser::_key_word_id<<(*it).first <<"\n";
}
}
static optional<unsigned> parse_optional_precedence(parser & p) {
if (p.curr_is_token(get_colon_tk())) {
p.next();
return some(parse_precedence_core(p));
} else {
return optional<unsigned>();
}
}
static unsigned parse_binders_rbp(parser & p) {
if (p.curr_is_token(get_colon_tk())) {
p.next();
return parse_precedence(p);
} else {
return 0;
}
}
static void load_command_variables(variables_map& variables, parser& metadata,
int argc, const char* argv[])
{
const auto options = metadata.load_options();
const auto arguments = metadata.load_arguments();
auto command_parser = command_line_parser(argc, argv).options(options)
.positional(arguments);
store(command_parser.run(), variables);
}
void type_modifiers::parse(parser & p) {
while (true) {
if (p.curr_is_token(get_class_tk())) {
m_is_class = true;
p.next();
} else {
break;
}
}
}
void parse(parser & p) {
while (true) {
if (p.curr_is_token(get_parsing_only_tk())) {
p.next();
m_parse_only = true;
} else if (auto prio = parse_priority(p)) {
m_priority = *prio;
} else {
return;
}
}
}
static void parse_notation_local(parser & p, buffer<expr> & locals) {
if (p.curr_is_identifier()) {
name n = p.get_name_val();
p.next();
expr local_type = mk_Prop(); // type used in notation local declarations, it is irrelevant
expr l = mk_local(n, local_type); // remark: the type doesn't matter
p.add_local(l);
locals.push_back(l);
} else {
throw parser_error("invalid notation declaration, identifier expected", p.pos());
}
}
inline bool _parse_codepoint(String& out, parser<Iter>& in)
{
int uni_ch;
if ((uni_ch = _parse_quadhex(in)) == -1)
{
return false;
}
if (0xd800 <= uni_ch && uni_ch <= 0xdfff)
{
if (0xdc00 <= uni_ch)
{
// a second 16-bit of a surrogate pair appeared
return false;
}
// first 16-bit of surrogate pair, get the next one
if (in.getc() != '\\' || in.getc() != 'u')
{
in.ungetc();
return false;
}
int second = _parse_quadhex(in);
if (!(0xdc00 <= second && second <= 0xdfff))
{
return false;
}
uni_ch = ((uni_ch - 0xd800) << 10) | ((second - 0xdc00) & 0x3ff);
uni_ch += 0x10000;
}
if (uni_ch < 0x80)
{
out.push_back(uni_ch);
}
else
{
if (uni_ch < 0x800)
{
out.push_back(0xc0 | (uni_ch >> 6));
}
else
{
if (uni_ch < 0x10000)
compiler::compiler(parser& p, void (*fp)(const char*)) :
m(fp), forwards(), callback(fp)
{
// Perform complete compilation
while ( compile_token(p.next_token(), p) )
; // loop
}
void parse(parser& parser)
{
//clear
clear();
//empty
if(parser.is_empty())
return;
//composite
if(try_composite(parser))
return;
//assign
if(try_assign(parser))
return;
//dereference
if(try_dereference(parser))
return;
//annotation
if(try_annotation(parser))
return;
//unit
check(try_unit(parser));
}
static bool load_configuration_variables(variables_map& variables,
parser& metadata)
{
const auto config_settings = metadata.load_settings();
const auto config_path = get_config_option(variables);
// If the existence test errors out we pretend there's no file :/.
error_code code;
if (!config_path.empty() && exists(config_path, code))
{
bc::ifstream file(config_path.string());
if (!file.good())
{
BOOST_THROW_EXCEPTION(reading_file(config_path.string().c_str()));
}
const auto config = parse_config_file(file, config_settings);
store(config, variables);
return true;
}
// Loading from an empty stream causes the defaults to populate.
std::stringstream stream;
const auto config = parse_config_file(stream, config_settings);
store(config, variables);
return false;
}
environment coercion_cmd(parser & p) {
auto pos = p.pos();
expr f = p.parse_expr();
if (!is_constant(f))
throw parser_error("invalid 'coercion' command, constant expected", pos);
if (p.curr_is_token(g_colon)) {
p.next();
pos = p.pos();
expr C = p.parse_expr();
if (!is_constant(C))
throw parser_error("invalid 'coercion' command, constant expected", pos);
return add_coercion(p.env(), const_name(f), const_name(C), p.ios());
} else {
return add_coercion(p.env(), const_name(f), p.ios());
}
}
void parser<mcld::MCLDDirectory>::printOptionDiff(const llvm::cl::Option &O,
const mcld::MCLDDirectory &V,
parser<mcld::MCLDDirectory>::OptVal Default,
size_t GlobalWidth) const
{
printOptionName(O, GlobalWidth);
outs() << "= " << V.name();
size_t VSize = V.name().size();
size_t NumSpaces = MaxOptWidth > VSize ? MaxOptWidth - VSize : 0;
outs().indent(NumSpaces) << " (default: ";
if (Default.hasValue())
outs() << Default.getValue().name();
else
outs() << "*no default*";
outs() << ")\n";
}
static void load_environment_variables(variables_map& variables,
parser& metadata)
{
const auto& environment_variables = metadata.load_environment();
const auto environment = parse_environment(environment_variables,
BS_ENVIRONMENT_VARIABLE_PREFIX);
store(environment, variables);
}
static expr parse_struct_expr_core(parser & p, pos_info const & pos, bool curly_bar) {
expr t = p.parse_expr();
buffer<name> field_names;
buffer<expr> field_values;
buffer<expr> using_exprs;
while (p.curr_is_token(get_comma_tk())) {
p.next();
pair<optional<name>, expr> id_e = p.parse_optional_assignment();
if (id_e.first) {
field_names.push_back(*id_e.first);
field_values.push_back(id_e.second);
} else {
using_exprs.push_back(id_e.second);
}
}
if (curly_bar)
p.check_token_next(get_rcurlybar_tk(), "invalid structure expression, '|}' expected");
else
p.check_token_next(get_rdcurly_tk(), "invalid structure expression, '⦄' expected");
buffer<expr> args;
args.push_back(t);
args.append(field_values);
args.append(using_exprs);
return p.save_pos(mk_structure_instance(to_list(field_names), args.size(), args.data()), pos);
}
static void parse_filters(parser & p, buffer<std::string> & pos_names, buffer<std::string> & neg_names) {
name plus("+"); name minus("-");
while (p.curr_is_token(get_comma_tk())) {
p.next();
if (p.curr_is_token(plus)) {
p.next();
pos_names.push_back(p.check_id_next("invalid find_decl command, identifier expected").to_string());
} else if (p.curr_is_token(minus)) {
p.next();
neg_names.push_back(p.check_id_next("invalid find_decl command, identifier expected").to_string());
} else {
pos_names.push_back(p.check_id_next("invalid find_decl command, '+', '-', or identifier expected").to_string());
}
}
}
void copy_inline_body(render_buf &output)
{
while (1) {
mem_chunk buf = output.get_free_mem();
if (!stream->read_body(buf)) {
break;
}
output.write(buf);
}
}
static environment mixfix_cmd(parser & p, mixfix_kind k, bool overload, notation_entry_group grp, bool persistent) {
notation_modifiers mods;
mods.parse(p);
flet<bool> set_allow_local(g_allow_local, !persistent);
auto nt = parse_mixfix_notation(p, k, overload, grp, mods.m_parse_only, mods.m_priority);
environment env = p.env();
if (nt.second)
env = add_user_token(env, *nt.second, persistent);
env = add_notation(env, nt.first, persistent);
return env;
}
static name parse_class(parser & p) {
if (p.curr_is_token(g_lbracket)) {
p.next();
name n;
if (p.curr_is_identifier())
n = p.get_name_val();
else if (p.curr_is_keyword() || p.curr_is_command())
n = p.get_token_info().value();
else
throw parser_error("invalid 'using' command, identifier or symbol expected", p.pos());
p.next();
p.check_token_next(g_rbracket, "invalid 'using' command, ']' expected");
return n;
} else {
return name();
}
}
static environment notation_cmd_core(parser & p, bool overload, notation_entry_group grp, bool persistent) {
notation_modifiers mods;
mods.parse(p);
flet<bool> set_allow_local(g_allow_local, !persistent);
environment env = p.env();
buffer<token_entry> new_tokens;
auto ne = parse_notation_core(p, overload, grp, new_tokens, mods.m_parse_only, mods.m_priority);
for (auto const & te : new_tokens)
env = add_user_token(env, te, persistent);
env = add_notation(env, ne, persistent);
return env;
}
environment set_line_cmd(parser & p) {
if (!p.curr_is_numeral())
throw parser_error("invalid #setline command, numeral expected", p.pos());
unsigned r = p.get_small_nat();
p.set_line(r);
p.next();
return p.env();
}
std::size_t message::read(std::istream& in,
boost::system::error_code& ec,
parser& http_parser)
{
// make sure that we start out with an empty message & clear error_code
clear();
ec.clear();
// parse data from file one byte at a time
boost::tribool parse_result;
char c;
while (in) {
in.read(&c, 1);
if ( ! in ) {
ec = make_error_code(boost::system::errc::io_error);
break;
}
http_parser.set_read_buffer(&c, 1);
parse_result = http_parser.parse(*this, ec);
if (! boost::indeterminate(parse_result)) break;
}
if (boost::indeterminate(parse_result)) {
if (http_parser.check_premature_eof(*this)) {
// premature EOF encountered
if (! ec)
ec = make_error_code(boost::system::errc::io_error);
} else {
// EOF reached when content length unknown
// assume it is the correct end of content
// and everything is OK
parse_result = true;
ec.clear();
}
}
return (http_parser.get_total_bytes_read());
}
cpp_ptr<cpp_type_alias> cpp_type_alias::parse(const parser &p, const cpp_name &scope, cpp_cursor cur)
{
assert(clang_getCursorKind(cur) == CXCursor_TypedefDecl
|| clang_getCursorKind(cur) == CXCursor_TypeAliasDecl);
auto name = detail::parse_name(cur);
auto target = parse_alias_target(cur, name);
auto result = detail::make_ptr<cpp_type_alias>(scope, std::move(name), detail::parse_comment(cur),
clang_getCursorType(cur), target);
p.register_type(*result);
return result;
}
static unsigned int
heap_analysis ()
{
// Run this analysis only in LTO mode
if (!in_lto_p)
return 0;
fprintf(dump_file, "\ncs618heap: STARTED.\n");
std::cerr<<"\ncs618heap: STARTED.\n"; //AN NEWADD
program.initialization ();
std::cerr << "Part 1 Done \n" ;
program.preprocess_control_flow_graph ();
std::cerr << "Part 2 Done \n" ;
program.print_parsed_data ();
program.print_original_cfg();
program.delete_block_aux ();
RESULT ("\n\n");
fprintf(dump_file, "\ncs618heap: ENDED.\n"); //AN NEWADD
std::cerr<<"\ncs618heap: ENDED.\n"; //AN NEWADD
return 0;
}
environment add_alias(parser & p, environment env, bool composite,
name const & full_id, levels const & ctx_levels, buffer<expr> const & ctx_params) {
name id;
if (composite)
id = name(name(full_id.get_prefix().get_string()), full_id.get_string());
else
id = name(full_id.get_string());
if (!empty(ctx_levels) || !ctx_params.empty()) {
expr r = mk_local_ref(full_id, ctx_levels, ctx_params);
env = p.add_local_ref(env, id, r);
}
if (full_id != id)
env = add_expr_alias_rec(env, id, full_id);
return env;
}
