public static dumpStack ( |
||
err | ||
Résultat | void |
public Map meta() { if (m_meta == null) { try { if (fpod.m_meta != null) { m_meta = (Map)fpod.m_meta; } else { InStream input = new SysInStream(fpod.m_store.read("meta.props")); m_meta = (Map)input.readProps().toImmutable(); input.close(); } } catch (Exception e) { Err.dumpStack(e); m_meta = Sys.m_emptyStrStrMap; } } return(m_meta); }
private static Map initVars() { Map vars = new Map(Sys.StrType, Sys.StrType); try { vars.caseInsensitive(true); // predefined vars.set("os.name", Environment.OSVersion.Platform.ToString()); vars.set("os.version", Environment.OSVersion.Version.ToString()); // environment variables IDictionary getenv = Environment.GetEnvironmentVariables(); foreach (DictionaryEntry de in getenv) { string key = (string)de.Key; string val = (string)de.Value; vars.set(key, val); } } catch (Exception e) { Err.dumpStack(e); } return((Map)vars.toImmutable()); }
public static Locale fromStr(string s, bool check) { int len = s.Length; try { if (len == 2) { if (FanStr.isLower(s)) { return(new Locale(s, s, null)); } } if (len == 5) { string lang = s.Substring(0, 2); string country = s.Substring(3, 2); if (FanStr.isLower(lang) && FanStr.isUpper(country) && s[2] == '-') { return(new Locale(s, lang, country)); } } } catch (Exception e) { Err.dumpStack(e); } if (!check) { return(null); } throw ParseErr.make("Locale", s).val; }
public static List list() { lock (m_podsByName) { // TODO - eventually we need a faster way to load // pod meta-data into memory without actually loading // every pod into memory if (m_allPodsList == null) { List names = Env.cur().findAllPodNames(); List pods = new List(Sys.PodType); for (int i = 0; i < names.sz(); ++i) { string name = (string)names.get(i); try { pods.add(doFind(name, true, null)); } catch (Exception e) { System.Console.WriteLine("ERROR: Invalid pod file: " + name); Err.dumpStack(e); } } m_allPodsList = pods.ro(); } return(m_allPodsList); } }
public static UriScheme find(string scheme, bool check) { // check cache lock (m_cache) { UriScheme cached = (UriScheme)m_cache[scheme]; if (cached != null) { return(cached); } } try { // lookup scheme type (avoid building index for common types) Type t = null; if (scheme == "fan") { t = Sys.FanSchemeType; } if (scheme == "file") { t = Sys.FileSchemeType; } if (t == null) { string qname = (string)Env.cur().index("sys.uriScheme." + scheme).first(); if (qname == null) { throw UnresolvedErr.make().val; } t = Type.find(qname); } // allocate instance UriScheme s = (UriScheme)t.make(); s.m_scheme = scheme; // add to cache lock (m_cache) { UriScheme cached = (UriScheme)m_cache[scheme]; if (cached != null) { return(cached); } m_cache[scheme] = s; } return(s); } catch (UnresolvedErr.Val) {} catch (System.Exception e) { Err.dumpStack(e); } if (!check) { return(null); } throw UnresolvedErr.make("Unknown scheme: " + scheme).val; }
public static Service start(Service self) { State state = null; try { lock (m_lock) { // start implies install install(self); // if already running, short circuit state = (State)byService[self]; if (state.running) { return(self); } // put into the running state state.running = true; } // onStart callback (outside of lock) self.onStart(); } catch (System.Exception e) { if (state != null) { state.running = false; } Err.dumpStack(e); } return(self); }
public static Service stop(Service self) { try { lock (m_lock) { // if not running, short circuit State state = (State)byService[self]; if (state == null || !state.running) { return(self); } // take out of the running state state.running = false; } // onStop (outside of lock) self.onStop(); } catch (System.Exception e) { Err.dumpStack(e); } return(self); }
private static List loadDatabase() { InStream input = null; List quantityNames = new List(Sys.StrType); try { // parse etc/sys/units.fog as big serialized list which contains // lists for each quantity (first item being the name) String path = "etc/sys/units.txt"; input = Env.cur().findFile(path).@in(); // parse each line string curQuantityName = null; List curQuantityList = null; string line; while ((line = input.readLine()) != null) { // skip comment and blank lines line = line.Trim(); if (line.StartsWith("//") || line.Length == 0) { continue; } // quanity sections delimited as "-- name (dim)" if (line.StartsWith("--")) { if (curQuantityName != null) { m_quantities[curQuantityName] = curQuantityList.toImmutable(); } curQuantityName = line.Substring(2, line.IndexOf('(') - 2).Trim(); curQuantityList = new List(Sys.UnitType); quantityNames.add(curQuantityName); continue; } // must be a unit try { Unit unit = Unit.define(line); curQuantityList.add(unit); } catch (Exception e) { System.Console.WriteLine("WARNING: Init unit in etc/sys/units.txt: " + line); System.Console.WriteLine(" " + e); } } m_quantities[curQuantityName] = curQuantityList.toImmutable(); } catch (Exception e) { try { input.close(); } catch (Exception) {} System.Console.WriteLine("WARNING: Cannot load lib/units.txt"); Err.dumpStack(e); } return((List)quantityNames.toImmutable()); }
////////////////////////////////////////////////////////////////////////// // When Done ////////////////////////////////////////////////////////////////////////// internal void sendWhenDone(Actor a, Future f) { // if already done, then set immediate flag // otherwise add to our when done list bool immediate = false; lock (this) { if (isDone()) { immediate = true; } else { if (whenDone == null) { whenDone = new ArrayList(); } whenDone.Add(new WhenDone(a, f)); } } // if immediate we are already done so enqueue immediately if (immediate) { try { a._enqueue(f, false); } catch (System.Exception e) { Err.dumpStack(e); } } }
public virtual OutStream writeProps(Map props, bool cls) { Charset origCharset = charset(); charset(Charset.utf8()); try { List keys = props.keys().sort(); int size = keys.sz(); long eq = '='; long nl = '\n'; for (int i = 0; i < size; ++i) { string key = (string)keys.get(i); string val = (string)props.get(key); writePropStr(key); writeChar(eq); writePropStr(val); writeChar(nl); } return(this); } finally { try { if (cls) { close(); } } catch (System.Exception e) { Err.dumpStack(e); } charset(origCharset); } }
public override void finish() { if (m_finished) { return; } try { // ensure reflected and emitted reflect(); emit(); m_finished = true; // map .NET members to my slots for reflection; if // mixin then we do this for both the interface and // the static methods only of the implementation class finishSlots(m_type, false); if (isMixin()) { finishSlots(m_auxType, true); } } catch (Exception e) { Err.dumpStack(e); throw Err.make("Cannot emitFinish: " + m_qname + "." + m_finishing, e).val; } finally { m_finishing = null; } }
public virtual string readAllStr(bool normalizeNewlines) { try { char[] buf = new char[4096]; int n = 0; bool normalize = normalizeNewlines; // read characters int last = -1; while (true) { int c = rChar(); if (c < 0) { break; } // grow buffer if needed if (n >= buf.Length) { char[] temp = new char[buf.Length * 2]; System.Array.Copy(buf, 0, temp, 0, n); buf = temp; } // normalize newlines and add to buffer if (normalize) { if (c == '\r') { buf[n++] = '\n'; } else if (last == '\r' && c == '\n') { } else { buf[n++] = (char)c; } last = c; } else { buf[n++] = (char)c; } } return(new string(buf, 0, n)); } finally { try { close(); } catch (System.Exception e) { Err.dumpStack(e); } } }
////////////////////////////////////////////////////////////////////////// // Static Init ////////////////////////////////////////////////////////////////////////// static Log() { try { m_handlers[0] = Sys.LogRecType.method("print", true).func(); } catch (System.Exception e) { m_handlers = new Func[0]; Err.dumpStack(e); } }
public System.Type emit() { if (m_type == null) { if (Debug) { Console.WriteLine("-- emit: " + m_qname); } // make sure we have reflected to setup slots reflect(); // if sys class, just load it by name string podName = m_pod.m_name; if (podName == "sys") { try { m_dotnetRepr = FanUtil.isDotnetRepresentation(this); m_type = System.Type.GetType(FanUtil.toDotnetImplTypeName(podName, m_name)); } catch (Exception e) { Err.dumpStack(e); throw Err.make("Cannot load precompiled class: " + m_qname, e).val; } } // otherwise we need to emit it else { try { System.Type[] types = FTypeEmit.emitAndLoad(m_ftype); this.m_type = types[0]; if (types.Length > 1) { this.m_auxType = types[1]; } } catch (Exception e) { Err.dumpStack(e); throw Err.make("Cannot emit: " + m_qname, e).val; } } // we are done with our ftype now, gc it this.m_ftype = null; } return(m_type); }
internal static void sendWhenDone(ArrayList list) { if (list == null) { return; } for (int i = 0; i < list.Count; ++i) { WhenDone wd = (WhenDone)list[i]; try { wd.actor._enqueue(wd.future, false); } catch (System.Exception e) { Err.dumpStack(e); } } }
public static Pod doFind(string name, bool check, FPod fpod) { try { lock (m_podsByName) { // TODO - .NET does not have soft references, so how could // we implement this? See the Pod.java for the java impl. Pod pod = (Pod)m_podsByName[name]; if (pod == null) { // if fpod is non-null, then we are "creating" this pod in // memory direct from the compiler, otherwise we need to // find the pod zip file and load it's meta-data if (fpod == null) { fpod = readFPod(name); } // sanity check if (fpod.m_podName != name) { throw new Exception("Mismatched pod name b/w pod.def and pod zip filename: " + fpod.m_podName + " != " + name); } // create the pod and register it pod = new Pod(fpod); m_podsByName[name] = pod; } return(pod); } } catch (UnknownPodErr.Val e) { if (!check) { return(null); } throw e; } catch (Exception e) { Err.dumpStack(e); if (!check) { return(null); } throw UnknownPodErr.make(name, e).val; } }
public static string toLocale(double self, string pattern) { try { // get current locale Locale locale = Locale.cur(); NumberFormatInfo df = locale.dec(); // handle special values if (System.Double.IsNaN(self)) { return(df.NaNSymbol); } if (self == System.Double.PositiveInfinity) { return(df.PositiveInfinitySymbol); } if (self == System.Double.NegativeInfinity) { return(df.NegativeInfinitySymbol); } // get default pattern if necessary if (pattern == null) { pattern = Env.cur().locale(Sys.m_sysPod, "float", "#,###.0##"); } // TODO: if value is < 10^-3 or > 10^7 it will be // converted to exponent string, so just bail on that string str = Double.toString(self); if (str.IndexOf('E') > 0) { str = self.ToString("0.#########"); } // parse pattern and get digits NumPattern p = NumPattern.parse(pattern); NumDigits d = new NumDigits(str); // route to common FanNum method return(FanNum.toLocale(p, d, df)); } catch (Exception e) { Err.dumpStack(e); return(self.ToString()); } }
public virtual void eachLine(Func f) { try { string line; while ((line = readLine()) != null) { f.call(line); } } finally { try { close(); } catch (System.Exception e) { Err.dumpStack(e); } } }
public override void add(Future f) { try { object key = toKey(f.m_msg); if (key != null) { pending[key] = f; } } catch (System.Exception e) { Err.dumpStack(e); } base.add(f); }
////////////////////////////////////////////////////////////////////////// // Lifecycle ////////////////////////////////////////////////////////////////////////// public static Service install(Service self) { try { List types = FanObj.@typeof(self).inheritance(); lock (m_lock) { // if already installed, short circuit if (self.isInstalled()) { return(self); } // add to byService map byService[self] = new State(self); // add to map for each type service implements for (int i = 0; i < types.sz(); ++i) { Type t = (Type)types.get(i); if (!isServiceType(t)) { continue; } Node node = new Node(self); Node x = (Node)byType[t.qname()]; if (x == null) { byType[t.qname()] = node; } else { while (x.next != null) { x = x.next; } x.next = node; } } } } catch (System.Exception e) { Err.dumpStack(e); } return(self); }
public virtual List readAllLines() { try { List list = new List(Sys.StrType); string line; while ((line = readLine()) != null) { list.add(line); } return(list); } finally { try { close(); } catch (System.Exception e) { Err.dumpStack(e); } } }
public virtual Buf readAllBuf() { try { long size = FanInt.Chunk.longValue(); Buf buf = Buf.make(size); while (readBuf(buf, size) != null) { ; } buf.flip(); return(buf); } finally { try { close(); } catch (System.Exception e) { Err.dumpStack(e); } } }
// This is mostly for testing right. // java.util.TimeZone java() // { // return java.util.TimeZone.getTimeZone(name.val); // } ////////////////////////////////////////////////////////////////////////// // Aliases ////////////////////////////////////////////////////////////////////////// private static void loadAliases() { Hashtable map = new Hashtable(); try { // read as props file //String sep = java.io.File.separator; //Map props = Env.cur().props(Sys.sysPod, Uri.fromStr("timezone-aliases.props"), Duration.Zero); Map props = Sys.m_sysPod.props(Uri.fromStr("timezone-aliases.props"), Duration.Zero); System.Diagnostics.Debug.WriteLine(props.size()); System.Console.WriteLine(props.size()); // map both simple name and full names to aliases map IDictionaryEnumerator it = props.pairsIterator(); while (it.MoveNext()) { string key = (string)it.Key; string val = (string)it.Value; // map by fullName map[key] = val; // map by simple name int slash = key.LastIndexOf('/'); if (slash > 0) { map[key.Substring(slash + 1)] = val; } } } catch (Exception e) { Err.dumpStack(e); Console.WriteLine("ERROR: Cannot read timezone-aliases.props"); } // save to field and force memory barrier sync TimeZone.aliases = map; lock (TimeZone.aliases) {} //synchronized(TimeZone.aliases) {} }
////////////////////////////////////////////////////////////////////////// // Documentation ////////////////////////////////////////////////////////////////////////// public override string doc() { if (!m_docLoaded) { try { Stream input = m_pod.fpod.m_store.read("doc/" + m_name + ".apidoc"); if (input != null) { try { FDoc.read(input, this); } finally { input.Close(); } } } catch (Exception e) { Err.dumpStack(e); } m_docLoaded = true; } return(m_doc); }
public virtual void log(LogRec rec) { if (!enabled(rec.m_level)) { return; } Func[] handlers = Log.m_handlers; for (int i = 0; i < handlers.Length; ++i) { try { handlers[i].call(rec); } catch (System.Exception e) { Err.dumpStack(e); } } }
static Locale() { Locale x; try { string name = CultureInfo.CurrentCulture.Name; if (name.Length != 5) { name = CultureInfo.CurrentCulture.TwoLetterISOLanguageName; } x = fromStr(name); } catch (Exception e) { Err.dumpStack(e); x = fromStr("en"); } defaultLocale = x; }
////////////////////////////////////////////////////////////////////////// // Documentation ////////////////////////////////////////////////////////////////////////// public string doc() { if (!m_docLoaded) { try { Stream input = fpod.m_store.read("doc/pod.fandoc"); if (input != null) { m_doc = SysInStream.make(input, Long.valueOf(1024L)).readAllStr(); } } catch (Exception e) { Err.dumpStack(e); } m_docLoaded = true; } return(m_doc); }
public override Future get() { Future f = base.get(); if (f != null) { try { object key = toKey(f.m_msg); if (key != null) { pending.Remove(key); } } catch (System.Exception e) { Err.dumpStack(e); } } return(f); }
////////////////////////////////////////////////////////////////////////// // Extension ////////////////////////////////////////////////////////////////////////// public static MimeType forExt(string s) { if (s == null) { return(null); } try { string val = (string)Sys.m_sysPod.props(m_etcUri, Duration.m_oneMin).get(FanStr.lower(s)); if (val == null) { return(null); } return(MimeType.fromStr(val)); } catch (System.Exception e) { System.Console.WriteLine("MimeType.forExt: " + s); Err.dumpStack(e); return(null); } }
public Facet decode(Type type, string s) { try { // if no string use make/defVal if (s.Length == 0) { return((Facet)type.make()); } // decode using normal Fantom serialization return((Facet)ObjDecoder.decode(s)); } catch (System.Exception e) { string msg = "ERROR: Cannot decode facet " + type + ": " + s; System.Console.WriteLine(msg); Err.dumpStack(e); m_map.Remove(type); throw IOErr.make(msg).val; } }