def relativeScope(fromScope, destScope):
"""relativeScope(fromScope, destScope) -> list
Given two globally-scoped names, return a minimal scoped name list
which identifies the destination scope, without clashing with another
identifier. For example, given IDL:
module M {
typedef short A;
typedef long B;
module N {
typedef string B;
interface I {
void op(in ::M::A x, in ::M::B y);
};
};
};
relativeScope(["M", "N", "I"], ["M", "A"]) -> ["A"]
relativeScope(["M", "N", "I"], ["M", "B"]) -> ["M", "B"]
If the only valid result is a globally-scoped name, the result list is
prefixed with None:
module O {
typedef short C;
};
module P {
module O {
interface J {
void op(in ::O::C z);
};
};
};
relativeScope(["P", "O", "J"], ["O", "C"]) -> [None, "O", "C"]
"""
if not fromScope:
# At global scope: just use the destination scope
return destScope
import _omniidl
rs = _omniidl.relativeScopedName(fromScope, destScope)
if rs is None:
# Compiler does not know about the scopes. Globally scope.
return [None] + destScope
else:
return rs
def relativeScope(fromScope, destScope):
"""relativeScope(fromScope, destScope) -> list
Given two globally-scoped names, return a minimal scoped name list
which identifies the destination scope, without clashing with another
identifier. For example, given IDL:
module M {
typedef short A;
typedef long B;
module N {
typedef string B;
interface I {
void op(in ::M::A x, in ::M::B y);
};
};
};
relativeScope(["M", "N", "I"], ["M", "A"]) -> ["A"]
relativeScope(["M", "N", "I"], ["M", "B"]) -> ["M", "B"]
If the only valid result is a globally-scoped name, the result list is
prefixed with None:
module O {
typedef short C;
};
module P {
module O {
interface J {
void op(in ::O::C z);
};
};
};
relativeScope(["P", "O", "J"], ["O", "C"]) -> [None, "O", "C"]
"""
if not fromScope:
# At global scope: just use the destination scope
return destScope
import _omniidl
rs = _omniidl.relativeScopedName(fromScope, destScope)
if rs is None:
# Compiler does not know about the scopes. Globally scope.
return [None] + destScope
else:
return rs
def relativeScope(fromScope, destScope):
"""relativeScope(fromScope, destScope) -> list
Given two globally-scoped names, return a minimal scoped name list
which identifies the destination scope, without clashing with another
identifier. For example, given IDL:
module M {
typedef short A;
typedef long B;
module N {
typedef string B;
interface I {
void op(in ::M::A x, in ::M::B y);
};
};
};
relativeScope(["M", "N", "I"], ["M", "A"]) -> ["A"]
relativeScope(["M", "N", "I"], ["M", "B"]) -> ["M", "B"]
If the only valid result is a globally-scoped name, the result list is
prefixed with None:
module O {
typedef short C;
};
module P {
module O {
interface J {
void op(in ::O::C z);
};
};
};
relativeScope(["P", "O", "J"], ["O", "C"]) -> [None, "O", "C"]
If either scoped name does not exist, returns None."""
import _omniidl
return _omniidl.relativeScopedName(fromScope, destScope)
def relativeScope(fromScope, destScope):
"""relativeScope(fromScope, destScope) -> list
Given two globally-scoped names, return a minimal scoped name list
which identifies the destination scope, without clashing with another
identifier. For example, given IDL:
module M {
typedef short A;
typedef long B;
module N {
typedef string B;
interface I {
void op(in ::M::A x, in ::M::B y);
};
};
};
relativeScope(["M", "N", "I"], ["M", "A"]) -> ["A"]
relativeScope(["M", "N", "I"], ["M", "B"]) -> ["M", "B"]
If the only valid result is a globally-scoped name, the result list is
prefixed with None:
module O {
typedef short C;
};
module P {
module O {
interface J {
void op(in ::O::C z);
};
};
};
relativeScope(["P", "O", "J"], ["O", "C"]) -> [None, "O", "C"]
If either scoped name does not exist, returns None."""
import _omniidl
return _omniidl.relativeScopedName(fromScope, destScope)