static Map read(Map defProps, Key key, List files)
{
if (files.isEmpty()) return defProps;
Map acc = defProps.dup();
for (int i=files.sz()-1; i>=0; --i)
{
InStream input = ((File)files.get(i)).@in();
try { acc.setAll(input.readProps()); }
finally { input.close(); }
}
return (Map)acc.toImmutable();
}
public static Map contents(ZipFile zipFile)
{
Map c = new Map(Sys.UriType, Sys.FileType);
IEnumerator e = zipFile.GetEnumerator();
while (e.MoveNext())
{
ZipEntry entry = (ZipEntry)e.Current;
ZipEntryFile f = new ZipEntryFile(zipFile, entry);
c.set(f.m_uri, f);
}
return c;
}
//////////////////////////////////////////////////////////////////////////
// Construction
//////////////////////////////////////////////////////////////////////////
public BootEnv()
{
this.m_args = initArgs();
this.m_vars = initVars();
this.m_host = initHost();
this.m_user = initUser();
this.m_in = new SysInStream(Console.OpenStandardInput());
this.m_out = new SysOutStream(Console.OpenStandardOutput());
this.m_err = new SysOutStream(Console.OpenStandardError());
this.m_homeDir = new LocalFile(new DirectoryInfo(Sys.m_homeDir), true).normalize();
this.m_tempDir = m_homeDir.plus(Uri.fromStr("temp/"), false);
}
private static void addProps(Hashtable index, Map props)
{
IDictionaryEnumerator en = props.pairsIterator();
while (en.MoveNext())
{
string key = (string)en.Key;
List val = (List)en.Value;
List master = (List)index[key];
if (master == null)
index[key] = val;
else
master.addAll(val);
}
}
//////////////////////////////////////////////////////////////////////////
// Public
//////////////////////////////////////////////////////////////////////////
public Type compile(File file, Map options)
{
// normalize the file path as our cache key
file = file.normalize();
// unless force=true, check the cache
if (!getOption(options, m_strForce, false))
{
CachedScript c = getCache(file);
// if cached, try to lookup type (it might have been GCed)
if (c != null)
{
Type t1 = Type.find(c.typeName, false);
if (t1 != null) return t1;
}
}
// generate a unique pod name
string podName = generatePodName(file);
// compile the script
Pod pod = compile(podName, file, options);
// get the primary type
List types = pod.types();
Type t = null;
for (int i=0; i<types.sz(); ++i)
{
t = (Type)types.get(i);
if (t.isPublic()) break;
}
if (t == null)
throw Err.make("Script file defines no public classes: " + file).val;
// put it into the cache
putCache(file, t);
return t;
}
private void modify()
{
// if readonly then throw readonly exception
if (m_isReadonly)
throw ReadonlyErr.make("Map is readonly").val;
// if we have a cached m_readonlyMap, then detach
// it so it remains m_immutable
if (m_readonlyMap != null)
{
m_readonlyMap.m_map = cloneMap(m_map);
m_readonlyMap = null;
}
}
public Map setAll(Map m)
{
modify();
IDictionaryEnumerator en = m.m_map.GetEnumerator();
while (en.MoveNext())
{
object key = en.Key;
object val = en.Value;
m_map[key] = val;
}
return this;
}
public Map ro()
{
if (m_isReadonly) return this;
if (m_readonlyMap == null)
{
Map ro = new Map(m_type);
ro.m_map = m_map;
ro.m_isReadonly = true;
ro.m_caseInsensitive = m_caseInsensitive;
ro.m_def = m_def;
m_readonlyMap = ro;
}
return m_readonlyMap;
}
public Map findAll(Func f)
{
Map acc = new Map(m_type);
if (this.ordered()) acc.ordered(true);
if (this.caseInsensitive()) acc.caseInsensitive(true);
IDictionaryEnumerator en = m_map.GetEnumerator();
while (en.MoveNext())
{
object key = en.Key;
object val = en.Value;
if (f.call(val, key) == Boolean.True)
acc.set(key, val);
}
return acc;
}
public Map addAll(Map m)
{
modify();
IDictionaryEnumerator en = m.m_map.GetEnumerator();
while (en.MoveNext())
{
object key = en.Key;
object val = en.Value;
add(key, val);
}
return this;
}
public static string encodeQuery(Map map)
{
StringBuilder buf = new StringBuilder(256);
IEnumerator en = map.keysEnumerator();
while (en.MoveNext())
{
string key = (string)en.Current;
string val = (string)map.get(key);
if (buf.Length > 0) buf.Append('&');
encodeQueryStr(buf, key);
if (val != null)
{
buf.Append('=');
encodeQueryStr(buf, val);
}
}
return buf.ToString();
}
private void normalizeQuery()
{
if (query == null)
query = emptyQuery();
}
internal void setQuery(Uri x)
{
queryStr = x.m_queryStr; query = x.m_query;
}
//////////////////////////////////////////////////////////////////////////
// Java Constructors
//////////////////////////////////////////////////////////////////////////
private Uri(Sections x)
{
m_scheme = x.scheme;
m_userInfo = x.userInfo;
m_host = x.host;
m_port = x.port;
m_pathStr = x.pathStr;
m_path = x.path.ro();
m_queryStr = x.queryStr;
m_query = x.query.ro();
m_frag = x.frag;
m_str = x.str != null ? x.str : new Encoder(this, false).encode();
}
private Map parseQuery(string q)
{
if (q == null) return null;
Map map = new Map(Sys.StrType, Sys.StrType);
try
{
int start = 0, eq = 0, len = q.Length, prev = 0;
bool escaped = false;
for (int i=0; i<len; ++i)
{
int ch = q[i];
if (prev != '\\')
{
if (ch == '=') eq = i;
if (ch != '&' && ch != ';') { prev = ch; continue; }
}
else
{
escaped = true;
prev = (ch != '\\') ? ch : 0;
continue;
}
if (start < i)
{
addQueryParam(map, q, start, eq, i, escaped);
escaped = false;
}
start = eq = i+1;
}
if (start < len)
addQueryParam(map, q, start, eq, len, escaped);
}
catch (Exception e)
{
// don't let internal error bring down whole uri
Err.dumpStack(e);
}
return map;
}
private void addQueryParam(Map map, string q, int start, int eq, int end, bool escaped)
{
string key, val;
if (start == eq && q[start] != '=')
{
key = toQueryStr(q, start, end, escaped);
val = "true";
}
else
{
key = toQueryStr(q, start, eq, escaped);
val = toQueryStr(q, eq+1, end, escaped);
}
string dup = (string)map.get(key);
if (dup != null) val = dup + "," + val;
map.set(key, val);
}
//////////////////////////////////////////////////////////////////////////
// Diagnostics
//////////////////////////////////////////////////////////////////////////
public override Map diagnostics()
{
// TODO: return empty map for now
Map d = new Map(Sys.StrType, Sys.ObjType);
return d;
}
public Uri plusQuery(Map q)
{
if (q == null || q.isEmpty()) return this;
Map merge = m_query.dup().setAll(q);
StringBuilder s = new StringBuilder(256);
IDictionaryEnumerator en = merge.pairsIterator();
while (en.MoveNext())
{
if (s.Length > 0) s.Append('&');
string key = (string)en.Key;
string val = (string)en.Value;
appendQueryStr(s, key);
s.Append('=');
appendQueryStr(s, val);
}
Sections t = new Sections();
t.scheme = m_scheme;
t.userInfo = m_userInfo;
t.host = m_host;
t.port = m_port;
t.frag = m_frag;
t.pathStr = m_pathStr;
t.path = m_path;
t.query = merge.ro();
t.queryStr = s.ToString();
return new Uri(t);
}
public Map dup()
{
Map dup = new Map(m_type);
dup.m_map = cloneMap(this.m_map);
return dup;
}
static Map emptyQuery()
{
Map q = m_emptyQuery;
if (q == null) q = m_emptyQuery = (Map)new Map(Sys.StrType, Sys.StrType).toImmutable();
return q;
}
public Map map(Func f)
{
Type r = f.returns();
if (r == Sys.VoidType) r = Sys.ObjType.toNullable();
Map acc = new Map(m_type.m_k, r);
if (this.ordered()) acc.ordered(true);
if (this.caseInsensitive()) acc.caseInsensitive(true);
IDictionaryEnumerator en = m_map.GetEnumerator();
while (en.MoveNext())
{
object key = en.Key;
object val = en.Value;
acc.set(key, f.call(val, key));
}
return acc;
}
public override Map @params()
{
if (m_params == null) m_params = makeParams();
return m_params;
}
public Map rw()
{
if (!m_isReadonly) return this;
Map rw = new Map(m_type);
rw.m_map = cloneMap(m_map);
rw.m_isReadonly = false;
rw.m_readonlyMap = this;
rw.m_caseInsensitive = m_caseInsensitive;
rw.m_def = m_def;
return rw;
}
public object readObj(Map opt)
{
return m_in.readObj(opt);
}
public override object toImmutable()
{
if (m_immutable) return this;
// make safe copy
IDictionary temp;
if (caseInsensitive()) temp = new Hashtable(new CIEqualityComparer());
else if (ordered()) temp = new OrderedDictionary();
else temp = new Hashtable();
IDictionaryEnumerator en = m_map.GetEnumerator();
while (en.MoveNext())
{
object key = en.Key;
object val = en.Value;
if (val != null)
{
if (val is List)
val = ((List)val).toImmutable();
else if (val is Map)
val = ((Map)val).toImmutable();
else if (!isImmutable(val))
throw NotImmutableErr.make("Item [" + key + "] not immutable " + @typeof(val)).val;
}
temp[key] = val;
}
// return new m_immutable m_map
Map ro = new Map(m_type, temp);
ro.m_isReadonly = true;
ro.m_immutable = true;
ro.m_caseInsensitive = m_caseInsensitive;
ro.m_def = m_def;
return ro;
}
public Buf writeObj(object obj, Map opt)
{
m_out.writeObj(obj, opt); return this;
}
//////////////////////////////////////////////////////////////////////////
// Option Utils
//////////////////////////////////////////////////////////////////////////
bool getOption(Map options, string key, bool def)
{
if (options == null) return def;
Boolean x = (Boolean)options.get(key);
if (x == null) return def;
return x.booleanValue();
}
public Buf writeProps(Map props)
{
m_out.writeProps(props); return this;
}
private Pod compile(string podName, File f, Map options)
{
// use Fantom reflection to run compiler::Main.compileScript(File)
Method m = Slot.findMethod("compiler::Main.compileScript", true);
return (Pod)m.call(podName, f, options);
}
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();
}
