struct Symbol* equality_expression(struct EqualityExpression* node)
{
if (node->type == 0)
return relational_expression(node->relationalExpression);
struct Symbol* symbol1 = load_symbol(equality_expression(node->equalityExpression));
struct Symbol* symbol2 = load_symbol(relational_expression(node->relationalExpression));
return equality_symbol(symbol1, symbol2, node->type, 0);
}
struct Symbol* shift_expression(struct ShiftExpression* node)
{
if (node->type == 0)
return additive_expression(node->additiveExpression);
struct Symbol* symbol1 = load_symbol(shift_expression(node->shiftExpression));
struct Symbol* symbol2 = load_symbol(additive_expression(node->additiveExpression));
return shift_symbol(symbol1, symbol2, node->type);
}
struct Symbol* multiplicative_expression(struct MultiplicativeExpression* node)
{
if (node->type == 0)
return cast_expression(node->castExpression);
struct Symbol* symbol1 = load_symbol(multiplicative_expression(node->multiplicativeExpression));
struct Symbol* symbol2 = load_symbol(cast_expression(node->castExpression));
return multiplicative_symbol(symbol1, symbol2, node->type);
}
struct Symbol* additive_expression(struct AdditiveExpression* node)
{
if (node->type == 0)
return multiplicative_expression(node->multiplicativeExpression);
struct Symbol* symbol1 = load_symbol(additive_expression(node->additiveExpression));
struct Symbol* symbol2 = load_symbol(multiplicative_expression(node->multiplicativeExpression));
return additive_symbol(symbol1, symbol2, node->type);
}
struct Symbol* inclusive_or_expression(struct InclusiveOrExpression* node)
{
if (node->type == 0)
return exclusive_or_expression(node->exclusiveOrExpression);
struct Symbol* symbol1 = load_symbol(inclusive_or_expression(node->inclusiveOrExpression));
struct Symbol* symbol2 = load_symbol(exclusive_or_expression(node->exclusiveOrExpression));
return inclusive_or_symbol(symbol1, symbol2, node->type);
}
struct Symbol* and_expression(struct AndExpression* node)
{
if (node->type == 0)
return equality_expression(node->equalityExpression);
struct Symbol* symbol1 = load_symbol(and_expression(node->andExpression));
struct Symbol* symbol2 = load_symbol(equality_expression(node->equalityExpression));
return and_symbol(symbol1, symbol2, node->type);
}
struct Symbol* exclusive_or_expression(struct ExclusiveOrExpression* node)
{
if (node->type == 0)
return and_expression(node->andExpression);
struct Symbol* symbol1 = load_symbol(exclusive_or_expression(node->exclusiveOrExpression));
struct Symbol* symbol2 = load_symbol(and_expression(node->andExpression));
return exclusive_or_symbol(symbol1, symbol2, node->type);
}
struct Symbol* conditional_expression(struct ConditionalExpression* node)
{
struct Symbol* symbol = logical_or_expression(node->logicalOrExpression);
if (node->type == 0)
return symbol;
ADDSTRING(" br i1 ");
code_gen_symbol('%', symbol);
struct Symbol* label1 = new_symbol("", 0, 0, 0, 0, 0, 0);
ADDSTRING(", label ");
code_gen_symbol('%', label1);
ADDSTRING(", label ");
char *ch = g_ptr;
ADDSTRING(" ");
ADDSTRING("\n; <label>:");
code_gen_symbol(0, label1);
ADDSTRING("\n");
struct Symbol* symbol1 = load_symbol(expression_func(node->expression));
ADDSTRING(" br label ");
char *ch1 = g_ptr;
ADDSTRING(" ");
ADDSTRING("\n; <label>:");
struct Symbol* label2 = new_symbol("", 0, 0, 0, 0, 0, 0);
code_gen_symbol(0, label2);
ADDSTRING("\n");
struct Symbol* symbol2 = load_symbol(expression_func(node->expression));
ADDSTRING(" br label ");
struct Symbol* label3 = new_symbol("", 0, 0, 0, 0, 0, 0);
code_gen_symbol('%', label3);
ADDSTRING("\n; <label>:");
code_gen_symbol(0, label3);
ADDSTRING("\n");
symbol = new_symbol("", symbol2->storage, symbol2->qualifier, symbol2->specifier, symbol2->stars, 0, symbol2->length);
code_gen_symbol('%', symbol);
ADDSTRING(" = phi ");
code_gen_type_specifier(symbol->specifier,0,symbol->length,symbol->stars);
ADDSTRING(" [ ");
code_gen_symbol('%', symbol1);
ADDSTRING(", ");
code_gen_symbol('%', label1);
ADDSTRING(" ], [ ");
code_gen_symbol('%', symbol2);
ADDSTRING(", ");
code_gen_symbol('%', label2);
ADDSTRING(" ]\n");
push_buffer(ch);
code_gen_symbol('%', label2);
*g_ptr = ' ';
pop_buffer();
push_buffer(ch1);
code_gen_symbol('%', label3);
*g_ptr = ' ';
pop_buffer();
return symbol;
}
struct Symbol* relational_expression(struct RelationalExpression* node)
{
if (node->type == 0)
return shift_expression(node->shiftExpression);
struct Symbol* symbol1 = load_symbol(relational_expression(node->relationalExpression));
struct Symbol* symbol2 = load_symbol(shift_expression(node->shiftExpression));
test_relation(&symbol1, &symbol2);
struct Symbol* symbol3;
if (node->type == 1)
symbol3 = test_calculable2(&symbol1, &symbol2, '<');
else
symbol3 = test_calculable2(&symbol1, &symbol2, '>');
if (symbol3)
return symbol3;
symbol3 = new_symbol("", 0, 2, 1, 0, 0, 0);
char c = 's';
if ((symbol1->specifier & (1 << 9)) > 0 || symbol1->stars)
c = 'u';
ADDSTRING(" ");
code_gen_symbol('%', symbol3);
if (symbol2->stars == 0 && (symbol2->specifier & (3 << 6)) != 0)
{
ADDSTRING(" = fcmp ");
if (node->type == 1 || node->type == 3)
{
ADDSTRING("olt ");
}
else
{
ADDSTRING("ogt ");
}
}
else
{
ADDSTRING(" = icmp ");
*g_ptr++ = c;
if (node->type == 1 || node->type == 3)
{
ADDSTRING("lt ");
}
else
{
ADDSTRING("gt ");
}
}
code_gen_type_specifier(symbol1->specifier,0, symbol1->length, symbol1->stars);
ADDSTRING(" ");
code_gen_symbol('%', symbol1);
ADDSTRING(", ");
code_gen_symbol('%', symbol2);
ADDSTRING("\n");
return symbol3;
}
void argument_expression_list(struct ArgumentExpressionList* node, struct SymbolList* symbol)
{
while (symbol)
{
push_arg_buf(symbol->symbol);
symbol = symbol->next;
}
push_arg(load_symbol(assignment_expression(node->assignmentExpression)));
while (node->type == 1)
{
node = node->argumentExpressionList;
push_arg(load_symbol(assignment_expression(node->assignmentExpression)));
}
cast_arg();
}
void furn_t::load( JsonObject &jo )
{
mandatory( jo, was_loaded, "name", name, translated_string_reader );
mandatory( jo, was_loaded, "move_cost_mod", movecost );
mandatory( jo, was_loaded, "required_str", move_str_req );
optional( jo, was_loaded, "max_volume", max_volume, legacy_volume_reader, DEFAULT_MAX_VOLUME_IN_SQUARE );
optional( jo, was_loaded, "crafting_pseudo_item", crafting_pseudo_item, "" );
load_symbol( jo );
transparent = false;
for( auto & flag : jo.get_string_array( "flags" ) ) {
set_flag( flag );
}
if( jo.has_member( "examine_action" ) ) {
examine = iexamine_function_from_string( jo.get_string( "examine_action" ) );
} else {
examine = iexamine_function_from_string( "none" );
}
optional( jo, was_loaded, "open", open, string_id_reader<furn_t> {}, NULL_ID );
optional( jo, was_loaded, "close", close, string_id_reader<furn_t> {}, NULL_ID );
bash.load( jo, "bash", true );
deconstruct.load( jo, "deconstruct", true );
}
void ter_t::load( JsonObject &jo, const std::string &src )
{
map_data_common_t::load( jo, src );
mandatory( jo, was_loaded, "name", name_ );
mandatory( jo, was_loaded, "move_cost", movecost );
optional( jo, was_loaded, "max_volume", max_volume, legacy_volume_reader, DEFAULT_MAX_VOLUME_IN_SQUARE );
optional( jo, was_loaded, "trap", trap_id_str );
load_symbol( jo );
trap = tr_null;
transparent = false;
connect_group = TERCONN_NONE;
for( auto &flag : jo.get_string_array( "flags" ) ) {
set_flag( flag );
}
// connect_group is initialized to none, then terrain flags are set, then finally
// connections from JSON are set. This is so that wall flags can set wall connections
// but can be overridden by explicit connections in JSON.
if( jo.has_member( "connects_to" ) ) {
set_connects( jo.get_string( "connects_to" ) );
}
optional( jo, was_loaded, "open", open, ter_str_id::NULL_ID() );
optional( jo, was_loaded, "close", close, ter_str_id::NULL_ID() );
optional( jo, was_loaded, "transforms_into", transforms_into, ter_str_id::NULL_ID() );
optional( jo, was_loaded, "roof", roof, ter_str_id::NULL_ID() );
bash.load( jo, "bash", false );
deconstruct.load( jo, "deconstruct", false );
}
/* Lookup and load web service symbols */
static int map_internals(struct duda_service *ds, struct duda_api_objects *api)
{
int (*cb_main) (struct duda_service *, struct duda_api_objects *);
/* Lookup and invoke duda_main() */
cb_main = (int (*)()) load_symbol(ds->dl_handle, "_duda_bootstrap");
cb_main(ds, api);
}
struct Symbol* logical_or_expression(struct LogicalOrExpression* node)
{
if (node->type == 0)
return logical_and_expression(node->logicalAndExpression);
struct Symbol* symbol1 = load_symbol(logical_or_expression(node->logicalOrExpression));
struct Symbol* symbol2 = load_symbol(logical_and_expression(node->logicalAndExpression));
struct Symbol* symbol3 = test_calculable2(&symbol1, &symbol2, 'a');
if (symbol3)
return symbol3;
symbol3 = new_symbol("0", 0, 2, 16, 0, 2, 0);
symbol3 = equality_symbol(symbol1, symbol3, 2, 1);
ADDSTRING(" br i1 ");
code_gen_symbol('%', symbol3);
struct Symbol* label1 = new_symbol("", 0, 0, 0, 0, 0, 0);
struct Symbol* label2 = new_symbol("", 0, 0, 0, 0, 0, 0);
ADDSTRING(", label ");
char *ch = g_ptr;
ADDSTRING(" ");
ADDSTRING(", label ");
code_gen_symbol('%', label1);
ADDSTRING("\n; <label>:");
code_gen_symbol(0, label1);
ADDSTRING("\n");
symbol1 = equality_symbol(symbol2, symbol3, 2, 1);
ADDSTRING(" br label ");
code_gen_symbol('%', label2);
ADDSTRING("\n; <label>:");
code_gen_symbol(0, label2);
ADDSTRING("\n");
ADDSTRING(" ");
symbol2 = new_symbol("", 0, 2, 2, 0, 0, 0);
code_gen_symbol('%', symbol2);
ADDSTRING(" = phi i1 [ true, %0 ], [ ");
code_gen_symbol('%', symbol1);
ADDSTRING(", ");
code_gen_symbol('%', label2);
ADDSTRING(" ]\n");
push_buffer(ch);
code_gen_symbol('%', label2);
*g_ptr = ' ';
pop_buffer();
return symbol2;
}
void ter_t::load( JsonObject &jo )
{
mandatory( jo, was_loaded, "name", name, translated_string_reader );
mandatory( jo, was_loaded, "move_cost", movecost );
optional( jo, was_loaded, "max_volume", max_volume, MAX_VOLUME_IN_SQUARE );
optional( jo, was_loaded, "trap", trap_id_str );
load_symbol( jo );
trap = tr_null;
transparent = false;
connect_group = TERCONN_NONE;
for( auto &flag : jo.get_string_array( "flags" ) ) {
set_flag( flag );
}
// connect_group is initialised to none, then terrain flags are set, then finally
// connections from JSON are set. This is so that wall flags can set wall connections
// but can be overridden by explicit connections in JSON.
if( jo.has_member( "connects_to" ) ) {
set_connects( jo.get_string( "connects_to" ) );
}
if( jo.has_member( "examine_action" ) ) {
examine = iexamine_function_from_string( jo.get_string( "examine_action" ) );
} else {
examine = iexamine_function_from_string( "none" );
}
optional( jo, was_loaded, "harvestable", harvestable );
optional( jo, was_loaded, "open", open, NULL_ID );
optional( jo, was_loaded, "close", close, NULL_ID );
optional( jo, was_loaded, "transforms_into", transforms_into, NULL_ID );
optional( jo, was_loaded, "roof", roof, NULL_ID );
if( jo.has_member("harvest_season") ) {
const std::string season = jo.get_string( "harvest_season" );
if( season == "SPRING" ) {
harvest_season = season_type::SPRING;
} else if( season == "SUMMER" ) {
harvest_season = season_type::SUMMER;
} else if( season == "AUTUMN" ) {
harvest_season = season_type::AUTUMN;
} else if( season == "WINTER" ) {
harvest_season = season_type::WINTER;
} else {
harvest_season = season_type::AUTUMN;
debugmsg( "Invalid harvest season \"%s\" in \"%s\".", season.c_str(), id.c_str() );
}
}
bash.load( jo, "bash", false );
deconstruct.load( jo, "deconstruct", false );
}
struct Symbol* cast_expression(struct CastExpression* node)
{
struct Symbol* symbol = 0;
if (node->type == 0)
return unary_expression(node->unaryExpression, &symbol);
int specifier = 0, stars = 0;
typename2specifier(node->typeName, &specifier, &stars);
symbol = cast_expression(node->castExpression);
symbol = load_symbol(symbol);
symbol = cast_symbol(symbol, specifier, stars);
return cast_expression(node->castExpression);
}
dynamic_loader::dynamic_loader(const std::string& path)
: handle_(0) {
void* handle = NULL;
std::string loaded_path;
if (is_absolute_or_relative_path(path)) {
// Load the plugin with the given path
handle = ::dlopen(path.c_str(), RTLD_LAZY);
loaded_path = path;
} else {
// Try to load the plugin from the plugin path environment
const char* plugin_dir = get_plugin_path();
if (plugin_dir) {
const std::string plugin_path =
std::string(plugin_dir) + "/" + path;
handle = ::dlopen(plugin_path.c_str(), RTLD_LAZY);
loaded_path = plugin_path;
}
// If failed, try to load it from the plugin directory specified on
// configure.
if (!handle) {
const std::string plugin_path =
std::string(JUBATUS_PLUGIN_DIR) + "/" + path;
handle = ::dlopen(plugin_path.c_str(), RTLD_LAZY);
loaded_path = plugin_path;
}
}
handle_ = handle;
if (!handle_) {
char* error = dlerror();
throw JUBATUS_EXCEPTION(
converter_exception(
"cannot load dynamic library: " + path + ": " + error)
<< jubatus::core::common::exception::error_api_func("dlopen")
<< jubatus::core::common::exception::error_file_name(path)
<< jubatus::core::common::exception::error_message(error));
} else {
try {
typedef std::string (*func_t)(void);
func_t version = reinterpret_cast<func_t>(load_symbol("version"));
LOG(INFO) << "plugin loaded: " << common::real_path(loaded_path)
<< " version: " << version();
} catch (converter_exception) {
LOG(WARN) << "plugin loaded: " << common::real_path(loaded_path)
<< " but version information is unavailable";
}
}
}
/* Code for leaf nodes in the expression parse tree: constants, strings,
* identifers, and so on. */
static
leaf_code(stream, node, need_lval) {
if ( node[0] == 'num' || node[0] == 'chr' || node[0] == 'str' ) {
if (node[0] == 'num') load_num(stream, node[3]);
else if (node[0] == 'chr') load_chr(stream, &node[3]);
else if (node[0] == 'str') {
auto lc = new_clabel();
defn_str(stream, &node[3], lc);
load_str(stream, lc);
}
}
else if ( node[0] == 'id' ) {
auto off, is_lval = lookup_sym( &node[3], &off );
auto need_addr = (is_lval == need_lval);
if (!off) load_symbol(stream, &node[3], need_addr);
else load_local(stream, off, need_addr);
}
else int_error("Unknown token '%Mc' in parse tree", node[0]);
}
void furn_t::load( JsonObject &jo, const std::string &src )
{
map_data_common_t::load( jo, src );
mandatory( jo, was_loaded, "name", name_ );
mandatory( jo, was_loaded, "move_cost_mod", movecost );
mandatory( jo, was_loaded, "required_str", move_str_req );
optional( jo, was_loaded, "max_volume", max_volume, legacy_volume_reader, DEFAULT_MAX_VOLUME_IN_SQUARE );
optional( jo, was_loaded, "crafting_pseudo_item", crafting_pseudo_item, "" );
optional( jo, was_loaded, "deployed_item", deployed_item );
load_symbol( jo );
transparent = false;
for( auto & flag : jo.get_string_array( "flags" ) ) {
set_flag( flag );
}
optional( jo, was_loaded, "open", open, string_id_reader<furn_t> {}, furn_str_id::NULL_ID() );
optional( jo, was_loaded, "close", close, string_id_reader<furn_t> {}, furn_str_id::NULL_ID() );
bash.load( jo, "bash", true );
deconstruct.load( jo, "deconstruct", true );
}
void init_global(void *lib_handle)
{
load_symbol(R_MPI_MESSAGE_NULL);
load_symbol(R_MPI_MESSAGE_NO_PROC);
load_symbol(R_MPI_GROUP_NULL);
load_symbol(R_MPI_COMM_NULL);
load_symbol(R_MPI_REQUEST_NULL);
load_symbol(R_MPI_OP_NULL);
load_symbol(R_MPI_NO_OP);
load_symbol(R_MPI_ERRHANDLER_NULL);
load_symbol(R_MPI_INFO_NULL);
load_symbol(R_MPI_INFO_ENV);
load_symbol(R_MPI_WIN_NULL);
load_symbol(R_MPI_FILE_NULL);
load_symbol(R_MPI_COMM_WORLD);
load_symbol(R_MPI_COMM_SELF);
load_symbol(R_MPI_GROUP_EMPTY);
load_symbol(R_MPI_MAX);
load_symbol(R_MPI_MIN);
load_symbol(R_MPI_SUM);
load_symbol(R_MPI_PROD);
load_symbol(R_MPI_LAND);
load_symbol(R_MPI_BAND);
load_symbol(R_MPI_LOR);
load_symbol(R_MPI_BOR);
load_symbol(R_MPI_LXOR);
load_symbol(R_MPI_BXOR);
load_symbol(R_MPI_MAXLOC);
load_symbol(R_MPI_MINLOC);
load_symbol(R_MPI_REPLACE);
load_symbol(R_MPI_DATATYPE_NULL);
load_symbol(R_MPI_BYTE);
load_symbol(R_MPI_PACKED);
load_symbol(R_MPI_CHAR);
load_symbol(R_MPI_SHORT);
load_symbol(R_MPI_INT);
load_symbol(R_MPI_LONG);
load_symbol(R_MPI_FLOAT);
load_symbol(R_MPI_DOUBLE);
load_symbol(R_MPI_LONG_DOUBLE);
load_symbol(R_MPI_UNSIGNED_CHAR);
load_symbol(R_MPI_SIGNED_CHAR);
load_symbol(R_MPI_UNSIGNED_SHORT);
load_symbol(R_MPI_UNSIGNED_LONG);
load_symbol(R_MPI_UNSIGNED);
load_symbol(R_MPI_FLOAT_INT);
load_symbol(R_MPI_DOUBLE_INT);
load_symbol(R_MPI_LONG_DOUBLE_INT);
load_symbol(R_MPI_LONG_INT);
load_symbol(R_MPI_SHORT_INT);
load_symbol(R_MPI_2INT);
load_symbol(R_MPI_UB);
load_symbol(R_MPI_LB);
load_symbol(R_MPI_WCHAR);
load_symbol(R_MPI_LONG_LONG_INT);
load_symbol(R_MPI_LONG_LONG);
load_symbol(R_MPI_UNSIGNED_LONG_LONG);
load_symbol(R_MPI_2COMPLEX);
load_symbol(R_MPI_2DOUBLE_COMPLEX);
load_symbol(R_MPI_CHARACTER);
load_symbol(R_MPI_LOGICAL);
load_symbol(R_MPI_LOGICAL1);
load_symbol(R_MPI_LOGICAL2);
load_symbol(R_MPI_LOGICAL4);
load_symbol(R_MPI_LOGICAL8);
load_symbol(R_MPI_INTEGER);
load_symbol(R_MPI_INTEGER1);
load_symbol(R_MPI_INTEGER2);
load_symbol(R_MPI_INTEGER4);
load_symbol(R_MPI_INTEGER8);
//load_symbol(R_MPI_INTEGER16);
load_symbol(R_MPI_REAL);
//load_symbol(R_MPI_REAL2);
load_symbol(R_MPI_REAL4);
load_symbol(R_MPI_REAL8);
load_symbol(R_MPI_REAL16);
load_symbol(R_MPI_DOUBLE_PRECISION);
load_symbol(R_MPI_COMPLEX);
load_symbol(R_MPI_COMPLEX8);
load_symbol(R_MPI_COMPLEX16);
load_symbol(R_MPI_COMPLEX32);
load_symbol(R_MPI_DOUBLE_COMPLEX);
load_symbol(R_MPI_2REAL);
load_symbol(R_MPI_2DOUBLE_PRECISION);
load_symbol(R_MPI_2INTEGER);
load_symbol(R_MPI_INT8_T);
load_symbol(R_MPI_UINT8_T);
load_symbol(R_MPI_INT16_T);
load_symbol(R_MPI_UINT16_T);
load_symbol(R_MPI_INT32_T);
load_symbol(R_MPI_UINT32_T);
load_symbol(R_MPI_INT64_T);
load_symbol(R_MPI_UINT64_T);
load_symbol(R_MPI_AINT);
load_symbol(R_MPI_OFFSET);
load_symbol(R_MPI_C_BOOL);
load_symbol(R_MPI_C_COMPLEX);
load_symbol(R_MPI_C_FLOAT_COMPLEX);
load_symbol(R_MPI_C_DOUBLE_COMPLEX);
load_symbol(R_MPI_C_LONG_DOUBLE_COMPLEX);
load_symbol(R_MPI_CXX_BOOL);
load_symbol(R_MPI_CXX_FLOAT_COMPLEX);
load_symbol(R_MPI_CXX_DOUBLE_COMPLEX);
load_symbol(R_MPI_CXX_LONG_DOUBLE_COMPLEX);
load_symbol(R_MPI_COUNT);
load_symbol(R_MPI_ERRORS_ARE_FATAL);
load_symbol(R_MPI_ERRORS_RETURN);
ccc_OMPI_C_MPI_DUP_FN=dlsym(lib_handle,"OMPI_C_MPI_DUP_FN");
ccc_OMPI_C_MPI_NULL_COPY_FN=dlsym(lib_handle,"OMPI_C_MPI_NULL_COPY_FN");
ccc_OMPI_C_MPI_NULL_DELETE_FN=dlsym(lib_handle,"OMPI_C_MPI_NULL_DELETE_FN");
}
struct Symbol* assignment_expression(struct AssignmentExpression* node)
{
if (node->type == 0)
return conditional_expression(node->conditionalExpression);
// to do
struct Symbol* orig_symbol;
struct Symbol* symbol2 = load_symbol(assignment_expression(node->assignmentExpression));
struct Symbol* symbol1 = unary_expression(node->unaryExpression, &orig_symbol);
struct Symbol* symbol3 = 0;
int specifier = symbol1->specifier;
test_changeable(orig_symbol);
if (node->assignmentOperator > 1)
{
switch (node->assignmentOperator) {
case 2:
symbol3 = multiplicative_symbol(symbol1, symbol2, 1);
break;
case 3:
symbol3 = multiplicative_symbol(symbol1, symbol2, 2);
break;
case 4:
symbol3 = multiplicative_symbol(symbol1, symbol2, 3);
break;
case 5:
symbol3 = additive_symbol(symbol1, symbol2, 1);
break;
case 6:
symbol3 = additive_symbol(symbol1, symbol2, 2);
break;
case 7:
symbol3 = shift_symbol(symbol1, symbol2, 1);
break;
case 8:
symbol3 = shift_symbol(symbol1, symbol2, 2);
break;
case 9:
symbol3 = and_symbol(symbol1, symbol2, 1);
break;
case 10:
symbol3 = exclusive_or_symbol(symbol1, symbol2, 1);
break;
case 11:
symbol3 = inclusive_or_symbol(symbol1, symbol2, 1);
break;
default:
break;
}
}
else
symbol3 = symbol2;
symbol3 = cast_symbol(symbol3, orig_symbol->specifier, orig_symbol->stars);
ADDSTRING(" store ");
code_gen_type_specifier(symbol1->specifier,0,symbol1->length,symbol1->stars);
ADDSTRING(" ");
code_gen_symbol('%', symbol3);
ADDSTRING(", ");
code_gen_type_specifier(orig_symbol->specifier,0,orig_symbol->length,orig_symbol->stars);
ADDSTRING("* ");
code_gen_symbol('%',orig_symbol);
ADDSTRING(", align ");
int l = len_gen_type_specifier(specifier);
sprintf(buf, "%d", l);
ADDSTRING(buf);
ADDSTRING("\n");
return symbol3;
}
struct Symbol* unary_expression(struct UnaryExpression* node, struct Symbol** orig_symbol)
{
int len;
struct Symbol *symbol, *symbol1 = NULL;
switch (node->type) {
case 0:
return postfix_expression(node->postfixExpression, orig_symbol);
case 1:
case 2:
symbol = load_symbol(unary_expression(node->unaryExpression, orig_symbol));
test_changeable(*orig_symbol);
if (node->type == 2)
symbol1 = test_calculable(symbol, '-');
else
symbol1 = test_calculable(symbol, '+');
if (symbol1)
return symbol1;
ADDSTRING(" ");
symbol1 = new_symbol("", symbol->storage, symbol->qualifier, symbol->specifier, symbol->stars - 1, 0, symbol->length);
code_gen_symbol('%', symbol1);
ADDSTRING(" = ");
if ((symbol->specifier & (3 << 6)) > 0)
{
ADDSTRING("f");
}
if (node->type == 1)
{
ADDSTRING("add ");
}
else
{
ADDSTRING("sub ");
}
code_gen_type_specifier(symbol->specifier,1,symbol->length, symbol->stars);
ADDSTRING(" ");
code_gen_symbol('%', symbol);
ADDSTRING(", ");
if ((symbol->specifier & (3 << 6)) > 0)
{
ADDSTRING("1.000000e+00\n");
}
else
{
ADDSTRING("1\n");
}
ADDSTRING(" store ");
code_gen_type_specifier(symbol->specifier,0,symbol->length, symbol->stars);
ADDSTRING(" ");
code_gen_symbol('%', symbol1);
ADDSTRING(", ");
code_gen_type_specifier(symbol->specifier,0,symbol->length, symbol->stars);
ADDSTRING("* ");
code_gen_symbol('%', *orig_symbol);
ADDSTRING(", align ");
int l = len_gen_type_specifier(symbol->specifier);
sprintf(buf, "%d", l);
ADDSTRING(buf);
ADDSTRING("\n");
*orig_symbol = 0;
break;
case 3:
symbol = cast_expression(node->castExpression);
switch (node->unaryOperator) {
case 1:
test_pointable(symbol);
symbol = symbol->reference;
*orig_symbol = 0;
symbol1 = new_symbol("", symbol->storage, 2, symbol->specifier, symbol->stars + 1, 0, symbol->length);
ADDSTRING(" ");
code_gen_symbol('%', symbol1);
ADDSTRING(" = getelementptr inbounds ");
code_gen_type_specifier(symbol->specifier, 0, symbol->length, symbol1->stars);
ADDSTRING(" ");
code_gen_symbol('%', symbol);
ADDSTRING(", ");
ADDSTRING(PTR_LEN_TYPE);
ADDSTRING(" 0\n");
break;
case 2:
test_referenceable(symbol);
symbol = load_symbol(symbol);
symbol1 = new_symbol("", symbol->storage, 0, symbol->specifier, symbol->stars - 1, 0, symbol->length);
*orig_symbol = symbol1;
if (symbol1->stars == 0)
symbol1->specifier = 32;
symbol1->reference = symbol;
ADDSTRING(" ");
code_gen_symbol('%', symbol1);
ADDSTRING(" = load ");
code_gen_type_specifier(symbol->specifier, 0, symbol->length, symbol->stars);
ADDSTRING(" ");
code_gen_symbol('%', symbol);
ADDSTRING(" ");
code_gen_symbol('%', symbol);
ADDSTRING(", align 8\n");
break;
case 3:
test_regular(symbol);
symbol1 = symbol;
*orig_symbol = 0;
break;
case 4:
test_regular(symbol);
symbol = load_symbol(symbol);
symbol1 = test_calculable(symbol, 'n');
if (symbol1)
{
return symbol1;
}
symbol1 = new_symbol("", symbol->storage, 2, symbol->specifier, symbol->stars, 0, 0);
*orig_symbol = symbol;
ADDSTRING(" ");
code_gen_symbol('%', symbol1);
if ((symbol->specifier & (3 << 6)) != 0)
{
ADDSTRING(" = f");
}
else
{
ADDSTRING(" = ");
}
ADDSTRING("sub ");
code_gen_type_specifier(symbol->specifier,1, symbol->length, symbol->stars);
ADDSTRING(" ");
if ((symbol->specifier & (3 << 6)) != 0)
{
ADDSTRING("0.000000e+00");
}
else
{
ADDSTRING("0");
}
ADDSTRING(", ");
code_gen_symbol('%', symbol);
ADDSTRING("\n");
*orig_symbol = 0;
break;
case 5:
test_integer(symbol);
symbol = load_symbol(symbol);
symbol1 = test_calculable(symbol, '~');
if (symbol1)
{
return symbol1;
}
*orig_symbol = 0;
symbol = cast_symbol(symbol, 16, 0);
symbol1 = new_symbol("", symbol->storage, symbol->qualifier, symbol->specifier, symbol->stars, 0, symbol->length);
ADDSTRING(" ");
code_gen_symbol('%', symbol1);
ADDSTRING(" = xor ");
code_gen_type_specifier(symbol->specifier,0, symbol->length, symbol->stars);
ADDSTRING(" ");
code_gen_symbol('%', symbol);
ADDSTRING(", -1");
ADDSTRING("\n");
break;
case 6:
*orig_symbol = 0;
symbol1 = test_calculable(symbol, '!');
symbol = load_symbol(symbol);
if (symbol1)
{
return symbol1;
}
symbol1 = new_symbol("0", 0, 2, 16, 0, 2, 0);
symbol1 = equality_symbol(symbol, symbol1, 2, 1);
break;
default:
break;
}
break;
case 4:
*orig_symbol = 0;
symbol = unary_expression(node->unaryExpression, orig_symbol);
if (symbol->stars > (symbol->length > 0))
len = PTR_LENGTH;
else
{
len = len_gen_type_specifier(symbol->specifier);
if (symbol->length)
len *= symbol->length;
}
sprintf(buf, "%d", len);
symbol1 = new_symbol(buf, 0, 2, 4, 0, 2, 0);
break;
case 5:
*orig_symbol = 0;
len = len_gen_type_name(node->typeName);
sprintf(buf, "%d", len);
symbol1 = new_symbol(buf, 0, 2, 4, 0, 2, 0);
break;
default:
break;
}
return symbol1;
}
struct Symbol* postfix_expression(struct PostfixExpression* node, struct Symbol** orig_symbol)
{
struct Symbol* symbol, *ref, *newSymbol = 0, *symbol1;
switch (node->type) {
case 0:
return primary_expression(node->primaryExpression, orig_symbol);
case 1:
symbol = load_symbol(postfix_expression(node->postfixExpression, orig_symbol));
test_referenceable(symbol);
ref = load_symbol(expression_func(node->expression));
*orig_symbol = new_symbol("", symbol->storage, 0, symbol->specifier, symbol->stars - 1, 0, 0);
if (symbol->stars == 1)
(*orig_symbol)->specifier = 32;
ADDSTRING(" ");
code_gen_symbol('%', *orig_symbol);
ADDSTRING(" = getelementptr inbounds ");
code_gen_type_specifier(symbol->specifier, 0, symbol->length, symbol->stars);
ADDSTRING(" ");
if (symbol->depth == 0)
code_gen_symbol('@', symbol);
else
code_gen_symbol('%', symbol);
if (symbol->length)
ADDSTRING(", i32 0");
ADDSTRING(", ");
test_integer(ref);
code_gen_type_specifier(ref->specifier, 0, 0, 0);
ADDSTRING(" ");
code_gen_symbol('%', ref);
ADDSTRING("\n");
ADDSTRING(" ");
newSymbol = new_symbol("", 0, 2, symbol->specifier, symbol->stars - 1, 0, 0);
newSymbol->reference = *orig_symbol;
code_gen_symbol('%', newSymbol);
ADDSTRING(" = load ");
code_gen_type_specifier(symbol->specifier, 0, (*orig_symbol)->length, symbol->stars);
ADDSTRING(" ");
code_gen_symbol('%', *orig_symbol);
ADDSTRING(", align ");
if (newSymbol->stars)
{
if (PTR_LENGTH == 8)
{
ADDSTRING("8\n");
}
else
{
ADDSTRING("4\n");
}
}
else
{
int len = len_gen_type_specifier(newSymbol->specifier);
sprintf(buf, "%d\n", len);
ADDSTRING(buf);
}
return newSymbol;
case 2:
case 3:
symbol = postfix_expression(node->postfixExpression, orig_symbol);
test_functionable(symbol);
if (node->type == 3)
{
argument_expression_list(node->argumentExpressionList, symbol->parameterlist);
}
if (!(symbol->specifier & 0x02)) {
newSymbol = new_symbol("", symbol->storage, 2, symbol->specifier, symbol->stars, 0, symbol->length);
ADDSTRING(" ");
code_gen_symbol('%', newSymbol);
ADDSTRING(" = call ");
} else {
ADDSTRING(" call ");
newSymbol = symbol;
}
if (strcmp(symbol->name, "free") != 0)
{
code_gen_type_specifier(symbol->specifier, 0, symbol->length, symbol->stars);
ADDSTRING(" ");
if (strcmp(symbol->name, "printf") == 0 || strcmp(symbol->name, "scanf") == 0)
{
ADDSTRING("(i8*, ...)* ");
}
code_gen_symbol('@', symbol);
}
else
{
ADDSTRING("i32 (");
code_gen_type_specifier(symbol_arg[0]->specifier, 0, 0, symbol_arg[0]->stars);
ADDSTRING(", ...)* bitcast (i32 (...)* @free to i32 (");
code_gen_type_specifier(symbol_arg[0]->specifier, 0, 0, symbol_arg[0]->stars);
ADDSTRING(", ...)*)");
}
ADDSTRING("(");
if (node->type == 3)
{
pop_arg();
}
ADDSTRING(")\n");
*orig_symbol = newSymbol;
return newSymbol;
case 4:
case 5:
// to do: struct
return 0;
case 6:
case 7:
symbol = load_symbol(postfix_expression(node->postfixExpression, orig_symbol));
test_changeable(*orig_symbol);
symbol1 = new_symbol("", symbol->storage, 2, symbol->specifier, symbol->stars, 0, symbol->length);
ADDSTRING(" ");
code_gen_symbol('%', symbol1);
ADDSTRING(" = ");
if ((symbol->specifier & (3 << 6)) > 0)
{
ADDSTRING("f");
}
if (node->type == 6)
{
ADDSTRING("add ");
}
else
{
ADDSTRING("sub ");
}
code_gen_type_specifier(symbol->specifier,1,symbol->length, symbol->stars);
ADDSTRING(" ");
code_gen_symbol('%', symbol);
ADDSTRING(", ");
if ((symbol->specifier & (3 << 6)) > 0)
{
ADDSTRING("1.000000e+00\n");
}
else
{
ADDSTRING("1\n");
}
ADDSTRING(" store ");
code_gen_type_specifier(symbol->specifier,0,symbol->length, symbol->stars);
ADDSTRING(" ");
code_gen_symbol('%', symbol1);
ADDSTRING(", ");
code_gen_type_specifier(symbol->specifier,0,symbol->length, symbol->stars);
ADDSTRING("* ");
code_gen_symbol('%', *orig_symbol);
ADDSTRING(", align ");
int l = len_gen_type_specifier(symbol->specifier);
sprintf(buf, "%d", l);
ADDSTRING(buf);
ADDSTRING("\n");
return symbol;
default:
return 0;
}
}
