private static bool AreCompatibleIntegers(
IReadOnlyList <Constant> arguments,
IntegerSpec initialSpec = null)
{
var spec = initialSpec;
foreach (var arg in arguments)
{
if (arg is IntegerConstant)
{
var constant = (IntegerConstant)arg;
if (spec == null)
{
spec = constant.Spec;
}
else if (!spec.Equals(constant.Spec))
{
return(false);
}
}
else
{
return(false);
}
}
return(true);
}
/// <summary> Initialize all members with the given number of tiles and components.
///
/// </summary>
/// <param name="nt">Number of tiles
///
/// </param>
/// <param name="nc">Number of components
///
/// </param>
public DecoderSpecs(int nt, int nc)
{
// Quantization
qts = new QuantTypeSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP);
qsss = new QuantStepSizeSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP);
gbs = new GuardBitsSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP);
// Wavelet transform
wfs = new SynWTFilterSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP);
dls = new IntegerSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP);
// Component transformation
cts = new CompTransfSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP);
// Entropy decoder
ecopts = new ModuleSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP);
ers = new ModuleSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP);
cblks = new CBlkSizeSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP);
// Precinct partition
pss = new PrecinctSizeSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, dls);
// Codestream
nls = new IntegerSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE);
pos = new IntegerSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE);
pcs = new ModuleSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE);
sops = new ModuleSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE);
ephs = new ModuleSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE);
pphs = new ModuleSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE);
iccs = new ModuleSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE);
pphs.setDefault((System.Object)false);
}
/// <summary>
/// Creates an intrinsic attribute that encodes an integer spec.
/// </summary>
/// <param name="specification">An integer specification.</param>
/// <returns>An intrinsic attribute.</returns>
public static IntrinsicAttribute Create(IntegerSpec specification)
{
return(new IntrinsicAttribute(
AttributeName,
new Constant[]
{
new IntegerConstant(specification.Size),
BooleanConstant.Create(specification.IsSigned)
}));
}
/// <summary>
/// Generates a random integer constant that conforms to a particular spec.
/// </summary>
/// <param name="random">A random number generator.</param>
/// <param name="spec">The spec for the integer constant to generate.</param>
/// <returns>An integer constant that conforms to its spec.</returns>
public static IntegerConstant NextIntegerConstant(this Random random, IntegerSpec spec)
{
var bigNum = BigInteger.Zero;
for (int i = 0; i < spec.Size / 30; i++)
{
bigNum = (bigNum << 30) | random.Next(0, 1 << 30);
}
bigNum = (bigNum << (spec.Size % 30)) | random.Next(0, 1 << (spec.Size % 30));
return(new IntegerConstant(bigNum, spec).Normalized);
}
/// <summary> Initialize all members with the given number of tiles and components
/// and the command-line arguments stored in a ParameterList instance
///
/// </summary>
/// <param name="nt">Number of tiles
///
/// </param>
/// <param name="nc">Number of components
///
/// </param>
/// <param name="imgsrc">The image source (used to get the image size)
///
/// </param>
/// <param name="pl">The ParameterList instance
///
/// </param>
public EncoderSpecs(int nt, int nc, BlkImgDataSrc imgsrc, ParameterList pl)
{
nTiles = nt;
nComp = nc;
// ROI
rois = new MaxShiftSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP);
// Quantization
pl.checkList(Quantizer.OPT_PREFIX, CSJ2K.j2k.util.ParameterList.toNameArray(Quantizer.ParameterInfo));
qts = new QuantTypeSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, pl);
qsss = new QuantStepSizeSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, pl);
gbs = new GuardBitsSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, pl);
// Wavelet transform
wfs = new AnWTFilterSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, qts, pl);
dls = new IntegerSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, pl, "Wlev");
// Component transformation
cts = new ForwCompTransfSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE, wfs, pl);
// Entropy coder
System.String[] strLcs = new System.String[] { "near_opt", "lazy_good", "lazy" };
lcs = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, "Clen_calc", strLcs, pl);
System.String[] strTerm = new System.String[] { "near_opt", "easy", "predict", "full" };
tts = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, "Cterm_type", strTerm, pl);
System.String[] strBoolean = new System.String[] { "on", "off" };
sss = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, "Cseg_symbol", strBoolean, pl);
css = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, "Ccausal", strBoolean, pl);
rts = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, "Cterminate", strBoolean, pl);
mqrs = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, "CresetMQ", strBoolean, pl);
bms = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, "Cbypass", strBoolean, pl);
cblks = new CBlkSizeSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, pl);
// Precinct partition
pss = new PrecinctSizeSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE_COMP, imgsrc, dls, pl);
// Codestream
sops = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE, "Psop", strBoolean, pl);
ephs = new StringSpec(nt, nc, ModuleSpec.SPEC_TYPE_TILE, "Peph", strBoolean, pl);
}
private static IntegerSpec UnionIntSpecs(
IntegerSpec firstSpec,
params IntegerSpec[] otherSpecs)
{
var spec = firstSpec;
foreach (var other in otherSpecs)
{
if (other.IsSigned != spec.IsSigned)
{
IntegerSpec signed;
IntegerSpec unsigned;
if (other.IsSigned)
{
signed = other;
unsigned = spec;
}
else
{
signed = spec;
unsigned = other;
}
if (signed.Size <= unsigned.Size)
{
spec = new IntegerSpec(unsigned.Size + 1, true);
}
else
{
spec = signed;
}
}
else if (other.Size > spec.Size)
{
spec = other;
}
}
return(spec);
}
/// <summary> Initializes this object with the given source of image data and with
/// all the decompositon parameters
///
/// </summary>
/// <param name="src">From where the image data should be obtained.
///
/// </param>
/// <param name="encSpec">The encoder specifications
///
/// </param>
/// <param name="cb0x">The horizontal coordinate of the code-block partition
/// origin on the reference grid.
///
/// </param>
/// <param name="cb0y">The vertical coordinate of the code-block partition origin
/// on the reference grid.
///
/// </param>
/// <seealso cref="ForwardWT">
///
/// </seealso>
public ForwWTFull(BlkImgDataSrc src, EncoderSpecs encSpec, int cb0x, int cb0y) : base(src)
{
this.src = src;
this.cb0x = cb0x;
this.cb0y = cb0y;
this.dls = encSpec.dls;
this.filters = encSpec.wfs;
this.cblks = encSpec.cblks;
this.pss = encSpec.pss;
int ncomp = src.NumComps;
int ntiles = src.getNumTiles();
currentSubband = new SubbandAn[ncomp];
decomposedComps = new DataBlk[ncomp];
subbTrees = new SubbandAn[ntiles][];
for (int i = 0; i < ntiles; i++)
{
subbTrees[i] = new SubbandAn[ncomp];
}
lastn = new int[ncomp];
lastm = new int[ncomp];
}
/// <summary> Creates a new ProgressionSpec object for the specified number of tiles,
/// components and the ParameterList instance.
///
/// </summary>
/// <param name="nt">The number of tiles
///
/// </param>
/// <param name="nc">The number of components
///
/// </param>
/// <param name="nl">The number of layer
///
/// </param>
/// <param name="dls">The number of decomposition levels specifications
///
/// </param>
/// <param name="type">the type of the specification module. The ProgressionSpec
/// class should only be used only with the type ModuleSpec.SPEC_TYPE_TILE.
///
/// </param>
/// <param name="pl">The ParameterList instance
///
/// </param>
public ProgressionSpec(int nt, int nc, int nl, IntegerSpec dls, byte type, ParameterList pl) : base(nt, nc, type)
{
System.String param = pl.getParameter("Aptype");
Progression[] prog;
int mode = -1;
if (param == null)
{
// No parameter specified
if (pl.getParameter("Rroi") == null)
{
mode = checkProgMode("res");
}
else
{
mode = checkProgMode("layer");
}
if (mode == -1)
{
System.String errMsg = "Unknown progression type : '" + param + "'";
throw new System.ArgumentException(errMsg);
}
prog = new Progression[1];
prog[0] = new Progression(mode, 0, nc, 0, dls.Max + 1, nl);
setDefault(prog);
return;
}
SupportClass.Tokenizer stk = new SupportClass.Tokenizer(param);
byte curSpecType = SPEC_DEF; // Specification type of the
// current parameter
bool[] tileSpec = null; // Tiles concerned by the specification
System.String word = null; // current word
System.String errMsg2 = null; // Error message
bool needInteger = false; // True if an integer value is expected
int intType = 0; // Type of read integer value (0=index of first
// resolution level, 1= index of first component, 2=index of first
// layer not included, 3= index of first resolution level not
// included, 4= index of first component not included
System.Collections.ArrayList progression = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10));
int tmp = 0;
Progression curProg = null;
while (stk.HasMoreTokens())
{
word = stk.NextToken();
switch (word[0])
{
case 't':
// If progression were previously found, store them
if (progression.Count > 0)
{
// Ensure that all information has been taken
curProg.ce = nc;
curProg.lye = nl;
curProg.re = dls.Max + 1;
prog = new Progression[progression.Count];
progression.CopyTo(prog);
if (curSpecType == SPEC_DEF)
{
setDefault(prog);
}
else if (curSpecType == SPEC_TILE_DEF)
{
for (int i = tileSpec.Length - 1; i >= 0; i--)
{
if (tileSpec[i])
{
setTileDef(i, prog);
}
}
}
}
progression.Clear();
intType = -1;
needInteger = false;
// Tiles specification
tileSpec = parseIdx(word, nTiles);
curSpecType = SPEC_TILE_DEF;
break;
default:
// Here, words is either a Integer (progression bound index)
// or a String (progression order type). This is determined by
// the value of needInteger.
if (needInteger)
{
// Progression bound info
try
{
tmp = (System.Int32.Parse(word));
}
catch (System.FormatException)
{
// Progression has missing parameters
throw new System.ArgumentException("Progression " + "order" + " specification " + "has missing " + "parameters: " + param);
}
switch (intType)
{
case 0: // cs
if (tmp < 0 || tmp > (dls.Max + 1))
{
throw new System.ArgumentException("Invalid res_start " + "in '-Aptype'" + " option: " + tmp);
}
curProg.rs = tmp; break;
case 1: // rs
if (tmp < 0 || tmp > nc)
{
throw new System.ArgumentException("Invalid comp_start " + "in '-Aptype' " + "option: " + tmp);
}
curProg.cs = tmp; break;
case 2: // lye
if (tmp < 0)
{
throw new System.ArgumentException("Invalid layer_end " + "in '-Aptype'" + " option: " + tmp);
}
if (tmp > nl)
{
tmp = nl;
}
curProg.lye = tmp; break;
case 3: // ce
if (tmp < 0)
{
throw new System.ArgumentException("Invalid res_end " + "in '-Aptype'" + " option: " + tmp);
}
if (tmp > (dls.Max + 1))
{
tmp = dls.Max + 1;
}
curProg.re = tmp; break;
case 4: // re
if (tmp < 0)
{
throw new System.ArgumentException("Invalid comp_end " + "in '-Aptype'" + " option: " + tmp);
}
if (tmp > nc)
{
tmp = nc;
}
curProg.ce = tmp; break;
}
if (intType < 4)
{
intType++;
needInteger = true;
break;
}
else if (intType == 4)
{
intType = 0;
needInteger = false;
break;
}
else
{
throw new System.ApplicationException("Error in usage of 'Aptype' " + "option: " + param);
}
}
if (!needInteger)
{
// Progression type info
mode = checkProgMode(word);
if (mode == -1)
{
errMsg2 = "Unknown progression type : '" + word + "'";
throw new System.ArgumentException(errMsg2);
}
needInteger = true;
intType = 0;
if (progression.Count == 0)
{
curProg = new Progression(mode, 0, nc, 0, dls.Max + 1, nl);
}
else
{
curProg = new Progression(mode, 0, nc, 0, dls.Max + 1, nl);
}
progression.Add(curProg);
}
break;
} // switch
} // while
if (progression.Count == 0)
{
// No progression defined
if (pl.getParameter("Rroi") == null)
{
mode = checkProgMode("res");
}
else
{
mode = checkProgMode("layer");
}
if (mode == -1)
{
errMsg2 = "Unknown progression type : '" + param + "'";
throw new System.ArgumentException(errMsg2);
}
prog = new Progression[1];
prog[0] = new Progression(mode, 0, nc, 0, dls.Max + 1, nl);
setDefault(prog);
return;
}
// Ensure that all information has been taken
curProg.ce = nc;
curProg.lye = nl;
curProg.re = dls.Max + 1;
// Store found progression
prog = new Progression[progression.Count];
progression.CopyTo(prog);
if (curSpecType == SPEC_DEF)
{
setDefault(prog);
}
else if (curSpecType == SPEC_TILE_DEF)
{
for (int i = tileSpec.Length - 1; i >= 0; i--)
{
if (tileSpec[i])
{
setTileDef(i, prog);
}
}
}
// Check that default value has been specified
if (getDefault() == null)
{
int ndefspec = 0;
for (int t = nt - 1; t >= 0; t--)
{
for (int c = nc - 1; c >= 0; c--)
{
if (specValType[t][c] == SPEC_DEF)
{
ndefspec++;
}
}
}
// If some tile-component have received no specification, they
// receive the default progressiveness.
if (ndefspec != 0)
{
if (pl.getParameter("Rroi") == null)
{
mode = checkProgMode("res");
}
else
{
mode = checkProgMode("layer");
}
if (mode == -1)
{
errMsg2 = "Unknown progression type : '" + param + "'";
throw new System.ArgumentException(errMsg2);
}
prog = new Progression[1];
prog[0] = new Progression(mode, 0, nc, 0, dls.Max + 1, nl);
setDefault(prog);
}
else
{
// All tile-component have been specified, takes the first
// tile-component value as default.
setDefault(getTileCompVal(0, 0));
switch (specValType[0][0])
{
case SPEC_TILE_DEF:
for (int c = nc - 1; c >= 0; c--)
{
if (specValType[0][c] == SPEC_TILE_DEF)
{
specValType[0][c] = SPEC_DEF;
}
}
tileDef[0] = null;
break;
case SPEC_COMP_DEF:
for (int t = nt - 1; t >= 0; t--)
{
if (specValType[t][0] == SPEC_COMP_DEF)
{
specValType[t][0] = SPEC_DEF;
}
}
compDef[0] = null;
break;
case SPEC_TILE_COMP:
specValType[0][0] = SPEC_DEF;
tileCompVal["t0c0"] = null;
break;
}
}
}
}
/// <summary> Creates a new PrecinctSizeSpec object for the specified number of tiles
/// and components.
///
/// </summary>
/// <param name="nt">The number of tiles
///
/// </param>
/// <param name="nc">The number of components
///
/// </param>
/// <param name="type">the type of the specification module i.e. tile specific,
/// component specific or both.
///
/// </param>
/// <param name="dls">Reference to the number of decomposition levels
/// specification
///
/// </param>
public PrecinctSizeSpec(int nt, int nc, byte type, IntegerSpec dls) : base(nt, nc, type)
{
this.dls = dls;
}
/// <summary> Creates a new PrecinctSizeSpec object for the specified number of tiles
/// and components and the ParameterList instance.
///
/// </summary>
/// <param name="nt">The number of tiles
///
/// </param>
/// <param name="nc">The number of components
///
/// </param>
/// <param name="type">the type of the specification module i.e. tile specific,
/// component specific or both.
///
/// </param>
/// <param name="imgsrc">The image source (used to get the image size)
///
/// </param>
/// <param name="pl">The ParameterList instance
///
/// </param>
public PrecinctSizeSpec(int nt, int nc, byte type, BlkImgDataSrc imgsrc, IntegerSpec dls, ParameterList pl) : base(nt, nc, type)
{
this.dls = dls;
// The precinct sizes are stored in a 2 elements vector array, the
// first element containing a vector for the precincts width for each
// resolution level and the second element containing a vector for the
// precincts height for each resolution level. The precincts sizes are
// specified from the highest resolution level to the lowest one
// (i.e. 0). If there are less elements than the number of
// decomposition levels, the last element is used for all remaining
// resolution levels (i.e. if the precincts sizes are specified only
// for resolutions levels 5, 4 and 3, then the precincts size for
// resolution levels 2, 1 and 0 will be the same as the size used for
// resolution level 3).
// Boolean used to know if we were previously reading a precinct's
// size or if we were reading something else.
bool wasReadingPrecinctSize = false;
System.String param = pl.getParameter(optName);
// Set precinct sizes to default i.e. 2^15 =
// Markers.PRECINCT_PARTITION_DEF_SIZE
System.Collections.ArrayList[] tmpv = new System.Collections.ArrayList[2];
tmpv[0] = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10)); // ppx
tmpv[0].Add((System.Int32)CSJ2K.j2k.codestream.Markers.PRECINCT_PARTITION_DEF_SIZE);
tmpv[1] = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10)); // ppy
tmpv[1].Add((System.Int32)CSJ2K.j2k.codestream.Markers.PRECINCT_PARTITION_DEF_SIZE);
setDefault(tmpv);
if (param == null)
{
// No precinct size specified in the command line so we do not try
// to parse it.
return;
}
// Precinct partition is used : parse arguments
SupportClass.Tokenizer stk = new SupportClass.Tokenizer(param);
byte curSpecType = SPEC_DEF; // Specification type of the
// current parameter
bool[] tileSpec = null; // Tiles concerned by the specification
bool[] compSpec = null; // Components concerned by the specification
int ci, ti; //i, xIdx removed
bool endOfParamList = false;
System.String word = null; // current word
System.Int32 w, h;
System.String errMsg = null;
while ((stk.HasMoreTokens() || wasReadingPrecinctSize) && !endOfParamList)
{
System.Collections.ArrayList[] v = new System.Collections.ArrayList[2]; // v[0] : ppx, v[1] : ppy
// We do not read the next token if we were reading a precinct's
// size argument as we have already read the next token into word.
if (!wasReadingPrecinctSize)
{
word = stk.NextToken();
}
wasReadingPrecinctSize = false;
switch (word[0])
{
case 't': // Tiles specification
tileSpec = parseIdx(word, nTiles);
if (curSpecType == SPEC_COMP_DEF)
{
curSpecType = SPEC_TILE_COMP;
}
else
{
curSpecType = SPEC_TILE_DEF;
}
break;
case 'c': // Components specification
compSpec = parseIdx(word, nComp);
if (curSpecType == SPEC_TILE_DEF)
{
curSpecType = SPEC_TILE_COMP;
}
else
{
curSpecType = SPEC_COMP_DEF;
}
break;
default:
if (!System.Char.IsDigit(word[0]))
{
errMsg = "Bad construction for parameter: " + word;
throw new System.ArgumentException(errMsg);
}
// Initialises Vector objects
v[0] = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10)); // ppx
v[1] = System.Collections.ArrayList.Synchronized(new System.Collections.ArrayList(10)); // ppy
while (true)
{
// Now get the precinct dimensions
try
{
// Get precinct width
w = System.Int32.Parse(word);
// Get next word in argument list
try
{
word = stk.NextToken();
}
catch (System.ArgumentOutOfRangeException)
{
errMsg = "'" + optName + "' option : could not " + "parse the precinct's width";
throw new System.ArgumentException(errMsg);
}
// Get precinct height
h = System.Int32.Parse(word);
if (w != (1 << MathUtil.log2(w)) || h != (1 << MathUtil.log2(h)))
{
errMsg = "Precinct dimensions must be powers of 2";
throw new System.ArgumentException(errMsg);
}
}
catch (System.FormatException)
{
errMsg = "'" + optName + "' option : the argument '" + word + "' could not be parsed.";
throw new System.ArgumentException(errMsg);
}
// Store packet's dimensions in Vector arrays
v[0].Add(w);
v[1].Add(h);
// Try to get the next token
if (stk.HasMoreTokens())
{
word = stk.NextToken();
if (!System.Char.IsDigit(word[0]))
{
// The next token does not start with a digit so
// it is not a precinct's size argument. We set
// the wasReadingPrecinctSize booleen such that we
// know that we don't have to read another token
// and check for the end of the parameters list.
wasReadingPrecinctSize = true;
if (curSpecType == SPEC_DEF)
{
setDefault(v);
}
else if (curSpecType == SPEC_TILE_DEF)
{
for (ti = tileSpec.Length - 1; ti >= 0; ti--)
{
if (tileSpec[ti])
{
setTileDef(ti, v);
}
}
}
else if (curSpecType == SPEC_COMP_DEF)
{
for (ci = compSpec.Length - 1; ci >= 0; ci--)
{
if (compSpec[ci])
{
setCompDef(ci, v);
}
}
}
else
{
for (ti = tileSpec.Length - 1; ti >= 0; ti--)
{
for (ci = compSpec.Length - 1; ci >= 0; ci--)
{
if (tileSpec[ti] && compSpec[ci])
{
setTileCompVal(ti, ci, v);
}
}
}
}
// Re-initialize
curSpecType = SPEC_DEF;
tileSpec = null;
compSpec = null;
// Go back to 'normal' parsing
break;
}
else
{
// Next token starts with a digit so read it
}
}
else
{
// We have reached the end of the parameters list so
// we store the last precinct's sizes and we stop
if (curSpecType == SPEC_DEF)
{
setDefault(v);
}
else if (curSpecType == SPEC_TILE_DEF)
{
for (ti = tileSpec.Length - 1; ti >= 0; ti--)
{
if (tileSpec[ti])
{
setTileDef(ti, v);
}
}
}
else if (curSpecType == SPEC_COMP_DEF)
{
for (ci = compSpec.Length - 1; ci >= 0; ci--)
{
if (compSpec[ci])
{
setCompDef(ci, v);
}
}
}
else
{
for (ti = tileSpec.Length - 1; ti >= 0; ti--)
{
for (ci = compSpec.Length - 1; ci >= 0; ci--)
{
if (tileSpec[ti] && compSpec[ci])
{
setTileCompVal(ti, ci, v);
}
}
}
}
endOfParamList = true;
break;
}
} // while (true)
break;
} // switch
} // while
}
/// <summary>
/// Decodes an LNode as a constant value.
/// </summary>
/// <param name="node">The node to decode.</param>
/// <param name="state">The decoder state to use.</param>
/// <returns>A decoded constant.</returns>
public override Constant Decode(LNode node, DecoderState state)
{
// Default-value constants.
if (node.IsIdNamed(CodeSymbols.Default))
{
return(DefaultConstant.Instance);
}
// Type/field/method token constants.
if (node.Calls(CodeSymbols.Typeof, 1))
{
return(new TypeTokenConstant(state.DecodeType(node.Args[0])));
}
else if (node.Calls(fieldofSymbol, 1))
{
return(new FieldTokenConstant(state.DecodeField(node.Args[0])));
}
else if (node.Calls(methodofSymbol, 1))
{
return(new MethodTokenConstant(state.DecodeMethod(node.Args[0])));
}
if (!FeedbackHelpers.AssertIsLiteral(node, state.Log))
{
return(null);
}
object value;
Symbol typeMarker;
// Custom literals.
if (TryDecomposeCustomLiteral(node, out value, out typeMarker))
{
// Arbitrary-width integer literals.
IntegerSpec spec;
if (IntegerSpec.TryParse(typeMarker.Name, out spec))
{
BigInteger integerVal;
if (BigInteger.TryParse(value.ToString(), out integerVal))
{
return(new IntegerConstant(integerVal, spec));
}
else
{
FeedbackHelpers.LogSyntaxError(
state.Log,
node,
FeedbackHelpers.QuoteEven(
"cannot parse ",
value.ToString(),
" as an integer."));
return(null);
}
}
else
{
FeedbackHelpers.LogSyntaxError(
state.Log,
node,
FeedbackHelpers.QuoteEven(
"unknown custom literal type ",
typeMarker.Name,
"."));
return(null);
}
}
value = node.Value;
// Miscellaneous constants: null, strings, Booleans.
if (value == null)
{
return(NullConstant.Instance);
}
else if (value is string)
{
return(new StringConstant((string)value));
}
else if (value is bool)
{
return(BooleanConstant.Create((bool)value));
}
// Floating-point numbers.
else if (value is float)
{
return(new Float32Constant((float)value));
}
else if (value is double)
{
return(new Float64Constant((double)value));
}
// Fixed-width integer constants and characters.
else if (value is char)
{
return(new IntegerConstant((char)value));
}
else if (value is sbyte)
{
return(new IntegerConstant((sbyte)value));
}
else if (value is short)
{
return(new IntegerConstant((short)value));
}
else if (value is int)
{
return(new IntegerConstant((int)value));
}
else if (value is long)
{
return(new IntegerConstant((long)value));
}
else if (value is byte)
{
return(new IntegerConstant((byte)value));
}
else if (value is ushort)
{
return(new IntegerConstant((ushort)value));
}
else if (value is uint)
{
return(new IntegerConstant((uint)value));
}
else if (value is ulong)
{
return(new IntegerConstant((ulong)value));
}
FeedbackHelpers.LogSyntaxError(
state.Log,
node,
new Text("unknown literal type."));
return(null);
}
