Hello community, here is the log from the commit of package yast2-ruby-bindings for openSUSE:12.2 checked in at 2012-06-26 17:44:01 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Comparing /work/SRC/openSUSE:12.2/yast2-ruby-bindings (Old) and /work/SRC/openSUSE:12.2/.yast2-ruby-bindings.new (New) ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Package is "yast2-ruby-bindings", Maintainer is "[email protected]" Changes: -------- --- /work/SRC/openSUSE:12.2/yast2-ruby-bindings/yast2-ruby-bindings.changes 2012-06-25 16:18:38.000000000 +0200 +++ /work/SRC/openSUSE:12.2/.yast2-ruby-bindings.new/yast2-ruby-bindings.changes 2012-06-26 17:44:02.000000000 +0200 @@ -4,0 +5 @@ +- 0.3.12 Old: ---- ruby1.9-patch yast2-ruby-bindings-0.3.11.tar.bz2 New: ---- yast2-ruby-bindings-0.3.12.tar.bz2 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ Other differences: ------------------ ++++++ yast2-ruby-bindings.spec ++++++ --- /var/tmp/diff_new_pack.zxqlPq/_old 2012-06-26 17:44:03.000000000 +0200 +++ /var/tmp/diff_new_pack.zxqlPq/_new 2012-06-26 17:44:03.000000000 +0200 @@ -15,17 +15,15 @@ # Please submit bugfixes or comments via http://bugs.opensuse.org/ # - # # spec file for package yast2-ruby-bindings (Version 0.1) # Name: yast2-ruby-bindings -Version: 0.3.11 +Version: 0.3.12 Release: 0 BuildRoot: %{_tmppath}/%{name}-%{version}-build Source0: yast2-ruby-bindings-%{version}.tar.bz2 -Patch0: ruby1.9-patch Prefix: /usr BuildRequires: cmake @@ -50,7 +48,6 @@ %prep %setup -n yast2-ruby-bindings-%{version} -%patch0 -p1 %build mkdir build cd build @@ -64,7 +61,6 @@ make %{?jobs:-j %jobs} VERBOSE=1 %install -chmod a+x tests/ycp/run_ycp_test.sh cd build make install DESTDIR=$RPM_BUILD_ROOT cd .. ++++++ yast2-ruby-bindings-0.3.11.tar.bz2 -> yast2-ruby-bindings-0.3.12.tar.bz2 ++++++ diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/yast2-ruby-bindings-0.3.11/VERSION.cmake new/yast2-ruby-bindings-0.3.12/VERSION.cmake --- old/yast2-ruby-bindings-0.3.11/VERSION.cmake 2012-06-07 17:45:44.000000000 +0200 +++ new/yast2-ruby-bindings-0.3.12/VERSION.cmake 2012-06-18 09:41:26.000000000 +0200 @@ -1,3 +1,3 @@ SET(VERSION_MAJOR "0") SET(VERSION_MINOR "3") -SET(VERSION_PATCH "11") +SET(VERSION_PATCH "12") diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/yast2-ruby-bindings-0.3.11/package/yast2-ruby-bindings.changes new/yast2-ruby-bindings-0.3.12/package/yast2-ruby-bindings.changes --- old/yast2-ruby-bindings-0.3.11/package/yast2-ruby-bindings.changes 2012-06-07 17:45:44.000000000 +0200 +++ new/yast2-ruby-bindings-0.3.12/package/yast2-ruby-bindings.changes 2012-06-18 09:41:26.000000000 +0200 @@ -1,4 +1,10 @@ ------------------------------------------------------------------- +Tue Jun 12 13:33:01 UTC 2012 - [email protected] + +- finish the ruby 1.9 port +- 0.3.12 + +------------------------------------------------------------------- Thu Jun 7 15:44:29 UTC 2012 - [email protected] - port to ruby 1.9 diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/yast2-ruby-bindings-0.3.11/src/ruby/Y2CCRuby.cc new/yast2-ruby-bindings-0.3.12/src/ruby/Y2CCRuby.cc --- old/yast2-ruby-bindings-0.3.11/src/ruby/Y2CCRuby.cc 2012-06-07 17:45:44.000000000 +0200 +++ new/yast2-ruby-bindings-0.3.12/src/ruby/Y2CCRuby.cc 2012-06-18 09:41:26.000000000 +0200 @@ -33,7 +33,7 @@ Y2Component *Y2CCRuby::provideNamespace (const char *name) { - y2milestone ("Y2CCRuby::provideNamespace %s", name); + y2debug ("Y2CCRuby::provideNamespace %s", name); if (strcmp (name, "Ruby") == 0) { // low level functions diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/yast2-ruby-bindings-0.3.11/src/ruby/Y2RubyTypeConv.cc new/yast2-ruby-bindings-0.3.12/src/ruby/Y2RubyTypeConv.cc --- old/yast2-ruby-bindings-0.3.11/src/ruby/Y2RubyTypeConv.cc 2012-06-07 17:45:44.000000000 +0200 +++ new/yast2-ruby-bindings-0.3.12/src/ruby/Y2RubyTypeConv.cc 2012-06-18 09:41:26.000000000 +0200 @@ -104,6 +104,10 @@ { VALUE value = (VALUE)value_v; + if (!YRuby::yRuby()) { + return; // we're finalized + } + YRuby::refcount_map_t& vrby = YRuby::yRuby()->value_references_from_ycp; YRuby::refcount_map_t::iterator it = vrby.find(value); if (it == vrby.end()) { diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/yast2-ruby-bindings-0.3.11/src/ruby/YRuby.cc new/yast2-ruby-bindings-0.3.12/src/ruby/YRuby.cc --- old/yast2-ruby-bindings-0.3.11/src/ruby/YRuby.cc 2012-06-07 17:45:44.000000000 +0200 +++ new/yast2-ruby-bindings-0.3.12/src/ruby/YRuby.cc 2012-06-18 09:41:26.000000000 +0200 @@ -28,6 +28,7 @@ // Ruby stuff #include <ruby.h> +#include <ruby/encoding.h> #define y2log_component "Y2Ruby" @@ -68,14 +69,19 @@ } YRuby * YRuby::_yRuby = 0; +bool YRuby::_y_ruby_finalized = false; YRuby::YRuby() { y2milestone( "Initializing ruby interpreter." ); + + RUBY_INIT_STACK; ruby_init(); ruby_script("yast"); ruby_init_loadpath(); + rb_enc_find_index("encdb"); + VALUE ycp_references = Data_Wrap_Struct(rb_cObject, gc_mark, gc_free, & value_references_from_ycp); rb_global_variable(&ycp_references); } @@ -107,13 +113,14 @@ { y2milestone( "Shutting down ruby interpreter." ); ruby_finalize(); + _y_ruby_finalized = true; } YRuby * YRuby::yRuby() { - if ( ! _yRuby ) + if ( ! _yRuby && !_y_ruby_finalized ) _yRuby = new YRuby(); return _yRuby; @@ -142,8 +149,9 @@ if ( argList->size() != 2 || ! argList->value(0)->isString() || ! argList->value(1)->isString() ) return YCPError( "Ruby::loadModule() / Ruby::Use() : Bad arguments: String expected!" ); string module_path = argList->value(1)->asString()->value(); - VALUE result = rb_require(module_path.c_str()); - if ( result == Qfalse ) + int error = 0; + VALUE result = rb_protect( (VALUE (*)(VALUE))rb_require, (VALUE) module_path.c_str(), &error); + if ( result == Qfalse || error) return YCPError( "Ruby::loadModule() / Can't load ruby module '" + module_path + "'" ); return YCPVoid(); } diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/yast2-ruby-bindings-0.3.11/src/ruby/YRuby.h new/yast2-ruby-bindings-0.3.12/src/ruby/YRuby.h --- old/yast2-ruby-bindings-0.3.11/src/ruby/YRuby.h 2012-06-07 17:45:44.000000000 +0200 +++ new/yast2-ruby-bindings-0.3.12/src/ruby/YRuby.h 2012-06-18 09:41:26.000000000 +0200 @@ -113,6 +113,7 @@ public: static YRuby * _yRuby; + static bool _y_ruby_finalized; refcount_map_t value_references_from_ycp; }; diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/yast2-ruby-bindings-0.3.11/src/ruby/YRubyNamespace.cc new/yast2-ruby-bindings-0.3.12/src/ruby/YRubyNamespace.cc --- old/yast2-ruby-bindings-0.3.11/src/ruby/YRubyNamespace.cc 2012-06-07 17:45:44.000000000 +0200 +++ new/yast2-ruby-bindings-0.3.12/src/ruby/YRubyNamespace.cc 2012-06-18 09:41:26.000000000 +0200 @@ -194,6 +194,9 @@ for(i = 0; i < RARRAY_LEN(methods); i++) { VALUE current = rb_funcall( methods, rb_intern("at"), 1, rb_fix_new(i) ); + if (rb_type(current) == RUBY_T_SYMBOL) { + current = rb_funcall( current, rb_intern("to_s"), 0); + } y2milestone("New method: '%s'", RSTRING_PTR(current)); // figure out arity. diff -urN '--exclude=CVS' '--exclude=.cvsignore' '--exclude=.svn' '--exclude=.svnignore' old/yast2-ruby-bindings-0.3.11/src/ruby/ptr new/yast2-ruby-bindings-0.3.12/src/ruby/ptr --- old/yast2-ruby-bindings-0.3.11/src/ruby/ptr 2012-06-07 17:45:44.000000000 +0200 +++ new/yast2-ruby-bindings-0.3.12/src/ruby/ptr 1970-01-01 01:00:00.000000000 +0100 @@ -1,217 +0,0 @@ -Y2RubyTypeTerm.cc:1:/*---------------------------------------------------------------------\ -Y2RubyTypeTerm.cc:11:\----------------------------------------------------------------------/ -Y2RubyTypeTerm.cc:13:Author: Duncan Mac-Vicar <[email protected]> -Y2RubyTypeTerm.cc:32: : term("init-me") -Y2RubyTypeTerm.cc:39://----------------------------------------------------------------------------- -Y2RubyTypeTerm.cc:47: wrapper->term = term; -Y2RubyTypeTerm.cc:63: return wrapper->term; -Y2RubyTypeTerm.cc:88: wrapper->term = YCPTerm( RSTRING(argv[0])->ptr ); -Y2RubyTypeTerm.cc:95: wrapper->term->add(rbvalue_2_ycpvalue(argv[i])); -Y2RubyTypeTerm.cc:117: wrapper->term->add(value); -Y2RubyTypeTerm.cc:138: return rb_str_new2(wrapper->term.toString().c_str()); -Y2RubyTypeTerm.cc:146: return rb_str_new2(wrapper->term.name().c_str()); -Y2RubyTypeTerm.cc:156:// wrapper->term->setName(RSTRING(name)->ptr); -Y2RubyTypeTerm.cc:166: rb_define_method( ryast_cTerm, "initialize", RB_METHOD( ryast_term_initialize ), -1 ); -Y2RubyTypeTerm.cc:167: rb_define_method( ryast_cTerm, "add", RB_METHOD( ryast_term_add ), -1 ); -Y2CCRuby.h:1:/*---------------------------------------------------------------------\ -Y2CCRuby.h:11:\----------------------------------------------------------------------/ -Y2CCRuby.h:13:Author: Duncan Mac-Vicar <[email protected]> -Y2CCRuby.h:28: * @short Y2ComponentCreator that creates Ruby-from-YCP bindings. -Y2CCRuby.h:31: * It receives a component name and - if it knows how to create -Y2CCRuby.h:32: * such a component - returns a newly created component of this -YRubyNamespace.cc:1:/*---------------------------------------------------------------------\ -YRubyNamespace.cc:11:\----------------------------------------------------------------------/ -YRubyNamespace.cc:13:Author: Duncan Mac-Vicar <[email protected]> -YRubyNamespace.cc:63: m_call->add (YCPVoid ()); -YRubyNamespace.cc:72: return YRuby::yRuby()->callInner ( m_module_name, -YRubyNamespace.cc:76: m_type->returnType() ); -YRubyNamespace.cc:84: m_call->set (position+1, arg); -YRubyNamespace.cc:96: // -1 for the function name -YRubyNamespace.cc:97: int params_so_far = m_call->size ()-1; -YRubyNamespace.cc:98: return m_type->parameterType (params_so_far); -YRubyNamespace.cc:107: y2internal("Adding parameter to function %s::%s of type %s", m_module_name.c_str(), m_local_name.c_str(), arg->valuetype_str()); -YRubyNamespace.cc:108: m_call->add (arg); -YRubyNamespace.cc:126: m_call->add (YCPVoid ()); -YRubyNamespace.cc:182: // we will perform operator- to determine the module methods -YRubyNamespace.cc:185: VALUE methods = rb_funcall( mymodulemethods, rb_intern("-"), 1, moduleklassmethods ); -YRubyNamespace.cc:194: for(i = 0; i < RARRAY(methods)->len; i++) -YRubyNamespace.cc:196: VALUE current = RARRAY(methods)->ptr[i]; -YRubyNamespace.cc:197: y2milestone("New method: '%s'", RSTRING(current)->ptr); -YRubyNamespace.cc:204: y2error ("Cannot access method object '%s'", RSTRING(current)->ptr); -YRubyNamespace.cc:213: if ( k < (arity - 1) ) -YRubyNamespace.cc:225: RSTRING(current)->ptr, // passed to Ustring, no need to strdup -YRubyNamespace.cc:228: fun_se->setGlobal (true); -YRubyNamespace.cc:231: y2milestone("method: '%s' added", RSTRING(current)->ptr); -YRubyNamespace.cc:241: fun_se->setGlobal (true); -YRubyNamespace.cc:281: TableEntry *func_te = table ()->find (name.c_str (), SymbolEntry::c_function); -YRubyNamespace.cc:284: constTypePtr t = required_type ? required_type : (constFunctionTypePtr)func_te->sentry()->type (); -YRuby.cc:1:/*---------------------------------------------------------------------\ -YRuby.cc:11:\----------------------------------------------------------------------/ -YRuby.cc:13:Author: Duncan Mac-Vicar <[email protected]> -YRuby.cc:87: y2milestone("mark: map size is %u", vrby->size()); -YRuby.cc:89: b = vrby->begin(), -YRuby.cc:90: e = vrby->end(), -YRuby.cc:93: y2milestone("marking: value %ld refcount %d", it->first, it->second); -YRuby.cc:94: rb_gc_mark(it->first); -YRuby.cc:102: y2milestone("free: map size is %u", vrby->size()); -YRuby.cc:142: if ( argList->size() != 2 || ! argList->value(0)->isString() || ! argList->value(1)->isString() ) -YRuby.cc:144: string module_path = argList->value(1)->asString()->value(); -YRuby.cc:151:// rb_protect-enabled rb_funcall, see below -YRuby.cc:177: // make rooms for size-1 arguments to -YRuby.cc:181: VALUE values[size-1+3]; -YRuby.cc:184: for ( ; i < size-1; ++i ) -YRuby.cc:187: YCPValue v = argList->value(i+1); -YRuby.cc:188: y2milestone("Adding argument %d of type %s", i, v->valuetype_str()); -YRuby.cc:192: y2milestone( "Will call function '%s' in module '%s' with '%d' arguments", function.c_str(), module_name.c_str(), size-1); -YRuby.cc:195: values[2] = size-1; -RubyLogger.cc:1:/*---------------------------------------------------------------------\ -RubyLogger.cc:11:\----------------------------------------------------------------------/ -RubyLogger.cc:13:Author: Duncan Mac-Vicar <[email protected]> -Y2RubyTypePath.h:1:/*---------------------------------------------------------------------\ -Y2RubyTypePath.h:11:\----------------------------------------------------------------------/ -Y2RubyTypePath.h:13:Author: Duncan Mac-Vicar <[email protected]> -Y2RubyComponent.cc:1:/*---------------------------------------------------------------------\ -Y2RubyComponent.cc:11:\----------------------------------------------------------------------/ -Y2RubyComponent.cc:13:Author: Duncan Mac-Vicar <[email protected]> -Y2RubyComponent.cc:68: module.erase (module.size () - 3 /* strlen (".pm") */); -Y2RubyComponent.cc:70: args->add (YCPString(/*module*/ name)); -Y2RubyComponent.cc:71: args->add (YCPString(/*module*/ module)); -Y2RubyTypeConv.cc:1:/*---------------------------------------------------------------------\ -Y2RubyTypeConv.cc:11:\----------------------------------------------------------------------/ -Y2RubyTypeConv.cc:13:Author: Duncan Mac-Vicar <[email protected]> -Y2RubyTypeConv.cc:62: * Internal helper for Hash -> YCPMap -Y2RubyTypeConv.cc:84: * Internal helper for Array -> YCPList -Y2RubyTypeConv.cc:107: YRuby::refcount_map_t& vrby = YRuby::yRuby()->value_references_from_ycp; -Y2RubyTypeConv.cc:110: // YRuby got re-constructed during final cleanup; do nothing -Y2RubyTypeConv.cc:114: int & count = it->second; -Y2RubyTypeConv.cc:115: --count; -Y2RubyTypeConv.cc:129: int count = ++YRuby::yRuby()->value_references_from_ycp[value]; -Y2RubyTypeConv.cc:147: if (ycpval->isVoid()) -Y2RubyTypeConv.cc:151: else if (ycpval->isBoolean()) -Y2RubyTypeConv.cc:153: return ycpval->asBoolean()->value() ? Qtrue : Qfalse; -Y2RubyTypeConv.cc:155: else if (ycpval->isString()) -Y2RubyTypeConv.cc:157: return rb_str_new2(ycpval->asString()->value().c_str()); -Y2RubyTypeConv.cc:159: else if (ycpval->isPath()) -Y2RubyTypeConv.cc:162: return rb_str_new2(ycpval->asPath()->asString()->value().c_str()); -Y2RubyTypeConv.cc:164: else if (ycpval->isTerm()) -Y2RubyTypeConv.cc:166: return ryast_rterm_from_yterm(ycpval->asTerm()); -Y2RubyTypeConv.cc:168: else if (ycpval->isInteger()) -Y2RubyTypeConv.cc:170: return INT2NUM( ycpval->asInteger()->value() ); -Y2RubyTypeConv.cc:172: else if (ycpval->isFloat()) -Y2RubyTypeConv.cc:174: return rb_float_new(ycpval->asFloat()->value()); -Y2RubyTypeConv.cc:176: else if ( ycpval->isMap() ) -Y2RubyTypeConv.cc:180: YCPMap map = ycpval->asMap(); -Y2RubyTypeConv.cc:183: for (YCPMap::const_iterator it = map->begin(); it != map->end(); ++it) -Y2RubyTypeConv.cc:185: YCPValue key = it->first; -Y2RubyTypeConv.cc:186: YCPValue value = it->second; -Y2RubyTypeConv.cc:191: else if (ycpval->isList()) -Y2RubyTypeConv.cc:195: YCPList list = ycpval->asList(); -Y2RubyTypeConv.cc:203: else if (ycpval->isSymbol()) -Y2RubyTypeConv.cc:205: YCPSymbol symbol = ycpval->asSymbol(); -Y2RubyTypeConv.cc:206: return rb_intern(symbol->symbol_cstr()); -Y2RubyTypeConv.cc:208: else if (ycpval->isExternal()) -Y2RubyTypeConv.cc:210: YCPExternal ex = ycpval->asExternal(); -Y2RubyTypeConv.cc:211: if (ex->magic() == string(YCP_EXTERNAL_MAGIC)) { -Y2RubyTypeConv.cc:212: return (VALUE)(ex->payload()); // FIXME reference counting -Y2RubyTypeConv.cc:214: y2error("Unexpected magic '%s'.", (ex->magic()).c_str()); -Y2RubyTypeConv.cc:216: rb_raise( rb_eTypeError, "Conversion of YCP type %s not supported", ycpval->toString().c_str() ); -Y2RubyComponent.h:1:/*---------------------------------------------------------------------\ -Y2RubyComponent.h:11:\----------------------------------------------------------------------/ -Y2RubyComponent.h:13:Author: Duncan Mac-Vicar <[email protected]> -YRuby.h:1:/*---------------------------------------------------------------------\ -YRuby.h:11:\----------------------------------------------------------------------/ -YRuby.h:13:Author: Duncan Mac-Vicar <[email protected]> -YRuby.h:48: * Load a Ruby module - equivalent to "use" in Ruby. -YRuby.h:102: * To protect them from being garbage-collected, they must be marked -Y2RubyUtils.h:1:/*---------------------------------------------------------------------\ -Y2RubyUtils.h:11:\----------------------------------------------------------------------/ -Y2RubyUtils.h:13:Author: Duncan Mac-Vicar <[email protected]> -Y2RubyTypePath.cc:12://----------------------------------------------------------------------------- -Y2RubyTypePath.cc:20: wrapper->path = path; -Y2RubyTypePath.cc:55: wrapper->path = YCPPath(); -Y2RubyTypePath.cc:74: rb_define_method( ryast_cPath, "initialize", RB_METHOD( ryast_path_initialize ), -1 ); -RubyLogger.h:1:/*---------------------------------------------------------------------\ -RubyLogger.h:11:\----------------------------------------------------------------------/ -RubyLogger.h:13:Author: Duncan Mac-Vicar <[email protected]> -ycp.rb:1:# -----------------------------------------------------------------------\ -ycp.rb:11:# \----------------------------------------------------------------------/ -ycp.rb:13:# Author: Duncan Mac-Vicar <[email protected]> -ycp.rb:24:#-------------------------------------- -ycp.rb:40: m.module_eval <<-"END" -ycp.rb:69: m.module_eval <<-"END" -ycp.rb:80:#-------------------------------------- -ycp.rb:110:#-------------------------------------- -ycp.rb:160:#-------------------------------------- -ycp.rb:205:#-------------------------------------- -Y2RubyTypeConv.h:1:/*---------------------------------------------------------------------\ -Y2RubyTypeConv.h:11:\----------------------------------------------------------------------/ -Y2RubyTypeConv.h:13:Author: Duncan Mac-Vicar <[email protected]> -Y2RubyTypeTerm.h:1:/*---------------------------------------------------------------------\ -Y2RubyTypeTerm.h:11:\----------------------------------------------------------------------/ -Y2RubyTypeTerm.h:13:Author: Duncan Mac-Vicar <[email protected]> -YRubyNamespace.h:1:/*---------------------------------------------------------------------\ -YRubyNamespace.h:11:\----------------------------------------------------------------------/ -YRubyNamespace.h:13:Author: Duncan Mac-Vicar <[email protected]> -Y2CCRuby.cc:1:/*---------------------------------------------------------------------\ -Y2CCRuby.cc:11:\----------------------------------------------------------------------/ -Y2CCRuby.cc:13:Author: Duncan Mac-Vicar <[email protected]> -YCP.cc:1:/*---------------------------------------------------------------------\ -YCP.cc:11:\----------------------------------------------------------------------/ -YCP.cc:13:Author: Duncan Mac-Vicar <[email protected]> -YCP.cc:24:#include <ycp-ui/YUIComponent.h> -YCP.cc:85: ns->initialize (); -YCP.cc:91:/*-------------------------------------------- -YCP.cc:93: * Document-module: YCP::Ui -YCP.cc:95: *-------------------------------------------- -YCP.cc:103: * call-seq: -YCP.cc:142: // got it - initialize, remember -YCP.cc:143: c->setServerOptions (0, NULL); -YCP.cc:149: y2debug ("UI component already present: %s", c->name ().c_str ()); -YCP.cc:155:/*-------------------------------------------- -YCP.cc:157: * Document-module: YCP -YCP.cc:163: *-------------------------------------------- -YCP.cc:187: y2internal("component name %s\n", c->name().c_str()); -YCP.cc:210: y2internal("namespace created from %s\n", ns->filename().c_str()); -YCP.cc:221: * call-seq: -YCP.cc:236: * ycp_module_each_symbol(namespace) -> iterator -YCP.cc:241: * call-seq: -YCP.cc:258: y2internal("got namespace from %s\n", ns->filename().c_str()); -YCP.cc:261: for (unsigned int i=0; i < ns->symbolCount(); ++i) -YCP.cc:263: SymbolEntryPtr s = ns->symbolEntry(i); -YCP.cc:265: rb_ary_push(arr, rb_str_new2(s->name())); -YCP.cc:266: rb_ary_push(arr, ID2SYM(rb_intern(s->catString().c_str()))); -YCP.cc:307: * each_builtin_symbol(name) -> iterator -YCP.cc:321: * call-seq: -YCP.cc:331: static_declarations.symbolTable()->forEach(__find_symbol); -YCP.cc:344: if ( ys->table() ) ys->table()->forEach(_yield_symbol_entry); -YCP.cc:357: * call-seq: -YCP.cc:366: static_declarations.symbolTable()->forEach(_yield_symbol_entry); -YCP.cc:404: //Y2Namespace *ns = c->import(namespace_name); -YCP.cc:413: y2internal("Namespace created from %s\n", ns->filename().c_str()); -YCP.cc:418: TableEntry *sym_te = ns->table()->find(function_name); -YCP.cc:427: if (sym_te->sentry ()->isVariable () || -YCP.cc:428: sym_te->sentry ()->isReference ()) -YCP.cc:432: //ret_yv = YCP_getset_variable (aTHX_ ns_name, sym_te->sentry (), args); -YCP.cc:436: Y2Function* call = ns->createFunctionCall(function_name, 0 /*Type::fromSignature("list<string>()")*/); -YCP.cc:448: call->appendParameter (v); -YCP.cc:450: call->finishParameters (); -YCP.cc:452: YCPValue res = call->evaluateCall (); -YCP.cc:455: //y2internal ("Result: %i\n", res->asList()->size()); -YCP.cc:523: constTypePtr act_param_tp = Type::vt2type (param_v->valuetype ()); -YCP.cc:527: constTypePtr err_tp = bi_call->attachParameter (param_c, act_param_tp); -YCP.cc:530: if (err_tp->isError ()) -YCP.cc:538: y2internal ("attachParameter returned %s", err_tp->toString ().c_str ()); -YCP.cc:546: constTypePtr err_tp = bi_call->finalize (RubyLogger::instance ()); -YCP.cc:551: err_tp->toString ().c_str (), qualified_name); -YCP.cc:557: YCPValue ret_yv = bi_call->evaluate (false /* no const subexpr elim */); -YCP.cc:578: res = _call_ycp_builtin( namespace_name, symbol_str, argc-2, argv+2); -YCP.cc:601: res = _call_ycp_builtin( "", function_name, argc-1, argv+1); -YCP.cc:606:/*-------------------------------------------- -YCP.cc:608: * Document-module: YaST -YCP.cc:612: *-------------------------------------------- -YCP.cc:633: y2_logger((loglevel_t)NUM2INT(argv[0]),RSTRING(argv[1])->ptr,RSTRING(argv[2])->ptr,NUM2INT(argv[3]),"",RSTRING(argv[5])->ptr); -YCP.cc:671: rb_define_singleton_method( rb_mYCP, "call_ycp_function", RUBY_METHOD_FUNC(ycp_module_call_ycp_function), -1); -YCP.cc:672: rb_define_singleton_method( rb_mYCP, "call_ycp_builtin", RUBY_METHOD_FUNC(ycp_module_call_ycp_builtin), -1); -YCP.cc:673: rb_define_singleton_method( rb_mYCP, "method_missing", RUBY_METHOD_FUNC(ycp_method_missing), -1); -YCP.cc:683: rb_define_singleton_method( rb_mUi, "init", RUBY_METHOD_FUNC(ui_init), -1); -YCP.cc:689: rb_define_method( rb_mYaST, "logger", RUBY_METHOD_FUNC(yast_y2_logger), -1); -- To unsubscribe, e-mail: [email protected] For additional commands, e-mail: [email protected]
