C++ (Cpp) SymbolPtr示例

示例#1

文件： findable.cpp 项目： mapleelpam/programnode-translator

SymbolPtr Findable::findType_downward( Scope* stable, const std::string& type_name )
{
	for( std::vector<SymbolPtr>::iterator I = stable->m_childs.begin(), B = stable->m_childs.end()
			; I != B ; I ++ )
	{

		if( (*I)->name() == type_name && (*I)->is(Symbol::T_SCOPE) )
		{
			ScopePtr pkg_symbol = DYNA_CAST( Scope, *I );
			if( pkg_symbol->getScopeType() == Scope::T_CLASS )
			{
				return *I;
			}
		}
		if( (*I)->name() == type_name && (*I)->is(Symbol::T_PRIMITIVE_TYPE) )
		{
			return *I;
		}
		if( (*I)->name() == "" && (*I)->is( Symbol::T_SCOPE) )
		{
			ScopePtr pkg_symbol = DYNA_CAST( Scope, *I );
			if( pkg_symbol->getScopeType() == Scope::T_PACKAGE ) {
				SymbolPtr found = findType_downward( pkg_symbol.get() , type_name );
				if( found )
					return found;
			}
		}
	}
	return SymbolPtr();
}

示例#2

文件： findable.cpp 项目： mapleelpam/programnode-translator

SymbolPtr Findable::findType( Scope* stable, const std::string& type_name )
{
	SymbolPtr found = findType_downward(stable, type_name );
	if( found ) return found;
	if( stable->m_parent )
		return findType( stable->m_parent, type_name );
	return SymbolPtr();
}

示例#3

文件： op.cpp 项目： alexarje/JamomaAudioGraph

TTErr OpSetup(OpPtr self)
{
	Atom a[2];
	
	a[0].a_type = A_POINTER;
	a[1].a_type = A_POINTER;
	a[0].a_w.w_symbol = SymbolPtr(self->audioGraphObject);
	a[1].a_w.w_symbol = 0;
	
	outlet_anything(self->outlet, gensym("audio.connect"), 2, a);
	return kTTErrNone;
}

示例#4

文件： namespace.cpp 项目： Ape/xboxdrv

SymbolPtr
Namespace::lookup(const std::string& name)
{
  Symbols::iterator it = m_symbols.find(name);
  if (it == m_symbols.end())
  {
    return SymbolPtr();
  }
  else
  {
    return it->second;
  }
}

示例#5

文件： environment.cpp 项目： Ape/xboxdrv

SymbolPtr
Environment::lookup_symbol(const std::string& ns, const std::string& symbol)
{
  log_debug(ns << " " << symbol);

  Namespaces::iterator it = m_namespaces.find(ns);
  if (it == m_namespaces.end())
  {
    return SymbolPtr();
  }
  else
  {
    return it->second->lookup(symbol);
  }
}

示例#6

文件： parser.cpp 项目： ghalib/scheme

SymbolPtr make_symbol(const std::string& symbol)
{
  return SymbolPtr(new Symbol(symbol));
}

示例#7

文件： SemanticAnalyzer.cpp 项目： jonfast565/Mikropascal-Compiler

SymbolPtr CodeBlock::translate(TokenPtr token) {
	if (token->get_token() == MP_ID) {
		string search_lexeme = token->get_lexeme();
		unsigned int search_level = this->get_nesting_level();
		SymbolListPtr filtered_data = this->get_analyzer()->get_symtable()->data_in_scope_at(search_lexeme, search_level);
		if (this->check_filter_size(filtered_data)) {
			SymbolPtr found = *filtered_data->begin();
			found->set_col(token->get_column());
			found->set_row(token->get_line());
			return found;
		} else {
			SymbolListPtr global_data = this->get_analyzer()->get_symtable()->data_in_scope_at(search_lexeme, 0);
			if (this->check_filter_size(global_data)) {
				SymbolPtr found = *global_data->begin();
				found->set_col(token->get_column());
				found->set_row(token->get_line());
				return found;
			} else {
				if (global_data == nullptr) {
					report_error_lc("Semantic Error", "ID '" + search_lexeme + "' not found",
									token->get_line(), token->get_column());
				} else {
					report_error("Semantic Error", "ID '" + search_lexeme + "' redefined as...");
					for (auto it = global_data->begin(); it != global_data->end(); it++) {
						SymDataPtr dptr = static_pointer_cast<SymData>(*it);
						report_error_lc("Definition @", (*it)->get_symbol_name() + " as " + var_type_to_string(dptr->get_var_type()), (*it)->get_row(), (*it)->get_col());
					}
				}
				this->valid = false;
				return nullptr;
			}
		}
	} else if (token->get_token() == MP_INT_LITERAL) {
		SymbolPtr s = SymbolPtr(new SymConstant(token->get_lexeme(), INTEGER_LITERAL));
		s->set_row(token->get_line());
		s->set_col(token->get_column());
		return s;
	} else if (token->get_token() == MP_STRING_LITERAL) {
		SymbolPtr s = SymbolPtr(new SymConstant(token->get_lexeme(), STRING_LITERAL));
		s->set_row(token->get_line());
		s->set_col(token->get_column());
		return s;
	} else if (token->get_token() == MP_FLOAT_LITERAL) {
		SymbolPtr s = SymbolPtr(new SymConstant(token->get_lexeme(), FLOATING_LITERAL));
		s->set_row(token->get_line());
		s->set_col(token->get_column());
		return s;
	} else if (token->get_token() == MP_TRUE) {
		SymbolPtr s = SymbolPtr(new SymConstant(token->get_lexeme(), BOOLEAN_LITERAL_T));
		s->set_row(token->get_line());
		s->set_col(token->get_column());
		return s;
	} else if (token->get_token() == MP_FALSE) {
		SymbolPtr s = SymbolPtr(new SymConstant(token->get_lexeme(), BOOLEAN_LITERAL_F));
		s->set_row(token->get_line());
		s->set_col(token->get_column());
		return s;
	} else if (token->get_token() == MP_LEFT_PAREN) {
		SymbolPtr s = SymbolPtr(new SymConstant(token->get_lexeme(), LPAREN));
		s->set_row(token->get_line());
		s->set_col(token->get_column());
		return s;
	} else if (token->get_token() == MP_RIGHT_PAREN) {
		SymbolPtr s = SymbolPtr(new SymConstant(token->get_lexeme(), RPAREN));
		s->set_row(token->get_line());
		s->set_col(token->get_column());
		return s;
	} else if (token->get_token() == MP_PLUS) {
		SymbolPtr s = SymbolPtr(new SymConstant(token->get_lexeme(), ADD));
		s->set_row(token->get_line());
		s->set_col(token->get_column());
		return s;
	} else if (token->get_token() == MP_MINUS) {
		SymbolPtr s = SymbolPtr(new SymConstant(token->get_lexeme(), SUB));
		s->set_row(token->get_line());
		s->set_col(token->get_column());
		return s;
	} else if (token->get_token() == MP_MULT) {
		SymbolPtr s = SymbolPtr(new SymConstant(token->get_lexeme(), MUL));
		s->set_row(token->get_line());
		s->set_col(token->get_column());
		return s;
	} else if (token->get_token() == MP_DIV) {
		SymbolPtr s = SymbolPtr(new SymConstant(token->get_lexeme(), DIV));
		s->set_row(token->get_line());
		s->set_col(token->get_column());
		return s;
	} else if (token->get_token() == MP_DIV_KW) {
		SymbolPtr s = SymbolPtr(new SymConstant(token->get_lexeme(), DIV));
		s->set_row(token->get_line());
		s->set_col(token->get_column());
		return s;
	} else if (token->get_token() == MP_MOD_KW) {
		SymbolPtr s = SymbolPtr(new SymConstant(token->get_lexeme(), MOD));
		s->set_row(token->get_line());
		s->set_col(token->get_column());
		return s;
	} else if (token->get_token() == MP_AND) {
		SymbolPtr s = SymbolPtr(new SymConstant(token->get_lexeme(), AND));
		s->set_row(token->get_line());
		s->set_col(token->get_column());
		return s;
	} else if (token->get_token() == MP_OR) {
		SymbolPtr s = SymbolPtr(new SymConstant(token->get_lexeme(), OR));
		s->set_row(token->get_line());
		s->set_col(token->get_column());
		return s;
	} else if (token->get_token() == MP_NOT) {
		SymbolPtr s = SymbolPtr(new SymConstant(token->get_lexeme(), NOT));
		s->set_row(token->get_line());
		s->set_col(token->get_column());
		return s;
	} else if (token->get_token() == MP_LESSTHAN) {
		SymbolPtr s = SymbolPtr(new SymConstant(token->get_lexeme(), ILT));
		s->set_row(token->get_line());
		s->set_col(token->get_column());
		return s;
	} else if (token->get_token() == MP_EQUALS) {
		SymbolPtr s = SymbolPtr(new SymConstant(token->get_lexeme(), IEQ));
		s->set_row(token->get_line());
		s->set_col(token->get_column());
		return s;
	} else if (token->get_token() == MP_LESSTHAN_EQUALTO) {
		SymbolPtr s = SymbolPtr(new SymConstant(token->get_lexeme(), ILE));
		s->set_row(token->get_line());
		s->set_col(token->get_column());
		return s;
	} else if (token->get_token() == MP_GREATERTHAN) {
		SymbolPtr s = SymbolPtr(new SymConstant(token->get_lexeme(), IGT));
		s->set_row(token->get_line());
		s->set_col(token->get_column());
		return s;
	} else if (token->get_token() == MP_GREATERTHAN_EQUALTO) {
		SymbolPtr s = SymbolPtr(new SymConstant(token->get_lexeme(), IGE));
		s->set_row(token->get_line());
		s->set_col(token->get_column());
		return s;
	} else if (token->get_token() == MP_NOT_EQUAL) {
		SymbolPtr s = SymbolPtr(new SymConstant(token->get_lexeme(), INE));
		s->set_row(token->get_line());
		s->set_col(token->get_column());
		return s;
	} else {
		return nullptr;
	}
}

示例#8

文件： symboltable.cpp 项目： gvillanueva/CST320

/*!
 * \brief   Finds a symbol in the current scope, returning it.
 * \param   symbolName  The name of the symbol to be retrieved.
 * \return  A wrapper around the matching symbol, if found. Otherwise a wrapper
 *          around NULL.
 */
SymbolPtr SymbolTable::SymbolTableScope::findSymbol(const char *symbolName)
{
    Symbol *symbol = findSymbolInternal(symbolName);
    return SymbolPtr(symbol);
}

示例#9

文件： SemanticAnalyzer.hpp 项目： jonfast565/Mikropascal-Compiler

	AssignmentBlock(bool expr_only): CodeBlock(ASSIGNMENT_BLOCK, nullptr), expr_type(VOID), expr_only(expr_only){
		this->assigner = SymbolPtr(new SymConstant("", VOID));
	};