Esempio n. 1
0
Object::operator const Poco::DynamicStruct& () const
{
	if (!_pStruct)
	{
		ValueMap::const_iterator it = _values.begin();
		ValueMap::const_iterator end = _values.end();
		_pStruct = new Poco::DynamicStruct;
		for (; it != end; ++it)
		{
			if (isObject(it))
			{
				_pStruct->insert(it->first, makeStruct(getObject(it->first)));
			}
			else if (isArray(it))
			{
				_pStruct->insert(it->first, Poco::JSON::Array::makeArray(getArray(it->first)));
			}
			else
			{
				_pStruct->insert(it->first, it->second);
			}
		}
	}

	return *_pStruct;
}
Esempio n. 2
0
Poco::DynamicStruct Object::makeStruct(const Object::Ptr& obj)
{
	Poco::DynamicStruct ds;

	ConstIterator it  = obj->begin();
	ConstIterator end = obj->end();
	for (; it != end; ++it)
	{
		if (obj->isObject(it))
		{
			Object::Ptr pObj = obj->getObject(it->first);
			DynamicStruct str = makeStruct(pObj);
			ds.insert(it->first, str);
		}
		else if (obj->isArray(it))
		{
			Array::Ptr pArr = obj->getArray(it->first);
			std::vector<Poco::Dynamic::Var> v = Poco::JSON::Array::makeArray(pArr);
			ds.insert(it->first, v);
		}
		else
			ds.insert(it->first, it->second);
	}

	return ds;
}
Esempio n. 3
0
void makeVisit() {                        //각 사람별로 모든 영화에 대해 관객수에 따라 영화를 볼것인지 아닌지 선택

	srand(time(NULL));
	int percent = 0;
	movie* temp;

	temp = chart;
	for (int i = 0; i < 1; i++) {
		for (int j = 0; j < MOVIE_NUM; j++) {
			percent = temp->audience / POPULATION;      // 관객수를 POPULATION으로 나누어 확률(0~100사이)를 구함
			test_aud[i]->visit[j] = 1;
			if (test_aud[i]->visit[j]) {
				test_aud[i]->view_count++;
				makeStruct(temp);
			}
			temp = temp->nextmovie;
		}
	}
}
Esempio n. 4
0
void BuiltIns::defineBuiltIns()
{
    auto factory = SymbolFactory{ };

    auto makeRef = [](auto&& type, bool is_const) { return VariableType(TypeFactory::getReference(type.get()), is_const); };

    auto global_scope = std::make_shared<GlobalScope>();
   
    auto int_          = factory.makeStruct("int", new StructScope("int", global_scope.get()));
    auto ref_int       = makeRef(int_, false);
    auto const_ref_int = makeRef(int_, true);

    auto char_          = factory.makeStruct("char", new StructScope("char", global_scope.get()));
    auto ref_char       = makeRef(char_, false);
    auto const_ref_char = makeRef(char_, true);

    auto str           = factory.makeStruct("string", new StructScope("string", global_scope.get()));
    auto ref_str       = makeRef(str, false);
    auto const_ref_str = makeRef(str, true);

    auto int_builtin  = VariableType(new BuiltInTypeSymbol("~~int", Comp::config().int_size), false);
    auto char_builtin = VariableType(new BuiltInTypeSymbol("~~char", Comp::config().int_size), false);

    auto simple_traits = FunctionTraits::simple();
    auto op_traits     = FunctionTraits::methodOper();
    auto meth_traits   = FunctionTraits::method();
    auto constr_traits = FunctionTraits::constructor();

    auto tp = FunctionType(int_.get(), {ref_int, int_.get()});

    auto void_type = std::make_unique<BuiltInTypeSymbol>("void", 0);

    global_scope -> define(factory.makeFunction("putchar", FunctionType(void_type.get(), {char_.get()}), simple_traits, false));
    global_scope -> define(factory.makeFunction("getchar", FunctionType(int_.get(), { }), simple_traits, false));

    auto string_builtin = VariableType(new BuiltInTypeSymbol("~~string", 256), false);    
    str -> defineMember(factory.makeVariable("~~impl", string_builtin, VariableSymbolType::FIELD));

    auto str_tp = FunctionType(ref_str, {ref_str, const_ref_str});
    
    int_ -> defineMember(factory.makeVariable("~~impl", int_builtin, VariableSymbolType::FIELD));
    
    int_ -> defineMethod(factory.makeFunction("int", FunctionType(ref_int, {ref_int}), constr_traits, false));
    int_ -> defineMethod(factory.makeFunction("int", FunctionType(ref_int, {ref_int, const_ref_int}), constr_traits, false));
    
    int_ -> defineMethod(factory.makeFunction("operator=", FunctionType(ref_int, {ref_int, const_ref_int}), op_traits, false));

    int_ -> defineMethod(factory.makeFunction("operator+", tp, op_traits, false));
    int_ -> defineMethod(factory.makeFunction("operator-", tp, op_traits, false));
    int_ -> defineMethod(factory.makeFunction("operator*", tp, op_traits, false));
    int_ -> defineMethod(factory.makeFunction("operator/", tp, op_traits, false));
    int_ -> defineMethod(factory.makeFunction("operator%", tp, op_traits, false));
    int_ -> defineMethod(factory.makeFunction("operator==", tp, op_traits, false));
    int_ -> defineMethod(factory.makeFunction("operator!=", tp, op_traits, false));
    int_ -> defineMethod(factory.makeFunction("operator&&", tp, op_traits, false));
    int_ -> defineMethod(factory.makeFunction("operator||", tp, op_traits, false));

    int_ -> defineMethod(factory.makeFunction("int", FunctionType(ref_int, {ref_int, char_.get()}), constr_traits, false));

    char_ -> defineMember(factory.makeVariable("~~impl", char_builtin, VariableSymbolType::FIELD));

    char_ -> defineMethod(factory.makeFunction("char", FunctionType(ref_char, {ref_char}), constr_traits, false));
    char_ -> defineMethod(factory.makeFunction("char", FunctionType(ref_char, {ref_char, const_ref_char}), constr_traits, false));
    char_ -> defineMethod(factory.makeFunction("char", FunctionType(ref_char, {ref_char, const_ref_int}), constr_traits, false));

    char_ -> defineMethod(factory.makeFunction("operator=", FunctionType(ref_char, {ref_char, const_ref_char}), constr_traits, false));

    str -> defineMethod(factory.makeFunction("string", str_tp, constr_traits, false));
    str -> defineMethod(factory.makeFunction("length", FunctionType(int_.get(), {ref_str}), meth_traits, false));

    str -> defineMethod(factory.makeFunction("operator[]", FunctionType(ref_char, {ref_str, int_.get()}), op_traits, false));
    str -> defineMethod(factory.makeFunction("operator+", FunctionType(str.get(), {ref_str, const_ref_str}), op_traits, false));
    str -> defineMethod(factory.makeFunction("operator=", str_tp, op_traits, false));

    global_scope -> define(factory.makeFunction("print", FunctionType(void_type.get(), {const_ref_str}), simple_traits, false));
    
    BuiltIns::int_type          = int_.get();
    BuiltIns::char_type         = char_.get();
    BuiltIns::ASCII_string_type = str.get();
    BuiltIns::void_type         = void_type.get();
    
    global_scope -> define(std::move(void_type));
    global_scope -> define(std::move(int_));
    global_scope -> define(std::move(str));
    global_scope -> define(std::move(char_));
    
    BuiltIns::global_scope      = global_scope;
}