This file documents changes to the Standard ML of New Jersey system
since January of 2014 (Versions after 110.78). Earlier changes are
documented in the HISTORY-pre2015
file. The change log primarily
covers the compiler, the compilation manager (CM), the MLRISC
library, and the runtime system. There are occasional entries about
other components (e.g., the SML/NJ Library and ML-LPT), but
these components have their own change logs that should be consulted.
Version 2022.1; 2022/08/25
- [2022/08/25]
-
Added
system/iter-make
script to iterate the compilation of the compiler. This script replaces the oldfixpt
script and is necessary when changing the version number of the system.
- [2022/08/15]
-
The change log file (
HISTORY.txt
) has been split into two files; one covering the period before 2015 and one covering changes since then.
- [2022/08/15]
-
The source repository has been migrated to GitHub. With this migration, we have substantially reorganized the source tree and build scripts.
The
base
directory has been eliminated; most of its components (cm
,compiler
,runtime
andsystem
) have been lifted to the top-level of the source tree. The other top-level directories aredoc
,libraries
,llvm
,smlnj-lib
, andtools
. Thelibraries
andtools
directories hold most of the non-core components of the system, such ascml
,ml-yacc
, etc.The
config/install.sh
script has been replaced by thebuild.sh
script. The build process is simplified because the only component that is not in the git repository is the boot files. We have also removed the deprecated support for 32-bit systems from the various build scripts.
- [2022/07/27]
- [2022/07/25]
-
Implemented Basis Library proposal 2021-001 (Add getWindowSz function to Posix.TTY structure).
- [2022/07/25]
-
Implemented Basis Library proposal 2022-001 (Add
tau
toMATH
signature).
- [2022/07/24]
-
Fix for ml-build fails on Windows with error.
- [2022/07/24]
- [2022/07/22]
- [2022/07/22]
- [2022/07/22]
- [2022/07/05]
-
Fixed bug #316 (
Real.fromManExp
does not return expected value ifman = 0.0
).
- [2022/07/05]
-
Fixed bug #317 (Conversion from string to real does not accept non-finite values).
- [2022/06/29]
-
Fixed bug #314 (
IEEEReal.float_class
does not match the Basis Library). For some reason, theNAN
constructor took an argument in our implementation. This code was probably an early design of the API that was changed in the Basis Library specification, but not in our code.
- [2022/06/29]
-
Fixed a pretty printing issue that arises when printing nested structure definitions. For example, opening the
OS
structure in the REPL, would result in an extra newline between the colon and thesig
keyword. This behavior is not present in the legacy version.
- [2022/06/27]
-
Adding support for generating a SIG_GC signal when there is a garbage collection. I have also added a function
val signalThreshold : int -> unit
to the
SMLofNJ.Internals.GC
structure that allows one to specify the threshold for generating a signal. The default is1
, which means that for any major collection a signal is generated. Setting the threshold to0
means that minor collections also generate signals, while setting the value to something greater than1
will filter out collections of younger generations. Collections that happen while asigGC
handler is running are ignored, which should not be an issue for thresholds of1
or greater.
- [2022/06/17]
-
Fixed bug #290 (Incorrect pattern matching for exceptons). The fix involves changes to
FLINT/opt/lcontract.sml
(functionswiInfo
) andFLINT/opt/fcontract.sml
(function fcSwitch). The contraction of a SWITCH with an constructor as subject is suppressed when the constructor is an exception constructor, because for exceptions comparison using the conrep field is inaccurate when the constructor is defined by an exception identity declaration (e.g.,exception B = A
).
- [2022/06/05]
-
Fixed bug #314 (
IEEEReal.setRoundingMode
is a no-op on Linux).
- [2022/06/05]
-
Fixed bug #312 (
CM.make
is unable to handle filenames that contain a backslash). We have changed the semantics of paths given to the functions in theCM
structure to be interpreted using the native pathname syntax (instead of CM's generic syntax).
- [2022/06/01]
-
Fixed bug #284 (Compiler bug: Contract: UsageMap on 132). The problem was the the
CPSTrans.cpstrans
function was generating code for loading spilled parameters in reverse order. In addition to fixing the bug, added some detailed documentation of the code.
- [2022/05/20]
-
Fixed bug #310 (Error when REPL tries to print value of type
Posix.FileSys.ST.stat
).
- [2022/05/10]
-
Fixed bug #306 (
Word8VectorSlice
: mapping a subslice produces wrong result or crashes SML/NJ).
- [2022/04/03]
-
Fix a module compilation performance bug by removing
packStr
andpackFct
fromElaborator/modules/sigmatch.sml
(reducing the size of that file by about 25%), and removing the call ofpackStr
(in functionconstrStr
) inElaborator/elaborate/elabmod.sml
, replacing it with a call toInstantiate.instAbstr
. Goodbye at last topackStr
!
Version 2021.1; 2021/12/31
- [2021/12/31]
-
Switched over to the LLVM version of the compiler. Doing so has two major consequences:
-
The MLRISC code generator that we have used for over 25 years has been replaced with one based on the https:llvm.org[LLVM Libraries].
-
We have dropped support for 32-bit systems. Since we do not have a 64-bit Windows port yet, this version only supports "Unix" systems on the AMD64 processor (we have tested Linux and *macOS). A 64-bit Windows version is a high priority and we hope to include it in the next release.
+
In addition, we have changed the version numbering scheme to a
YYYY.NN
scheme, where YYYY
is the year of the release and
NN
is the release number for the year.
- [2021/12/07]
-
Fixed a bug in the way that non-printable
char
values were being printed in the REPL.
- [2021/11/23]
-
Remove last traces of the lambda splitting support from CM.
- [2021/11/23]
-
Changed the
Binfile
structure (andBINFILE
signature) to support both the old binfile format and a new format (both formats are documented in thedev-notes/binfile.adoc
file). We are stiull using the old format, but will be switching to the new format soon. The new format has a more structured header and removes the vestigial support for the FLINT lambda pickles.The new header format includes a proper version number, which should make migrating to new binfile formats easier.
- [2021/11/07]
-
Committed changes to fix bug #281 (Redundant error messages for when a constructor name is misspelled). Revision r7357.
-
Modified
Absyn.value
datatype by adding an error constructorERRORid
. -
Revised
ElabData/staticenv/lookup.sml
to simplify and improve some functions (lookVal
→lookIdPath
,lookValSym
→lookIdSym
) and added a functionlookIdSymOp
that returns an option. -
Revised
pat_id
and deletedmakeAPPpat
inElabUtil
. -
Revised
elabPat
inElabCore
.
- [2021/11/07]
-
Committed a massive set of changes from "merge/base" working directory that contained manually merged changes from "newmc" into a fresh checkout of the trunk. Base version of the trunk was r7349, which was tagged to produce
$smlnj/sml/tags/pre-merge
. The merged trunk version is r7352.The changes include:
-
A completely rewritten match compiler that transforms absyn to absyn. The old match compiler files in FLINT/trans have been deleted. The new match compiler is documented in
dev-notes/match-compiler/match-compiler.txt
(and successor documents). The match compiler code is in the new directorybase/compiler/Elaborator/matchcomp
.FLINT/trans/translate.sml
and related files were also extensively revised to work with the new match compiler. -
PLAMBDA/FLINT types modules in
FLINT/kernel
have been revised so that the signatures of the main modules (Lty
,LtyKernel
,LtyDef
,LtyBasic
,LtyExtern
) are all disjoint. Function and record metadata stuctures that were in the FLINT structure (FLINT/flint/flint.sml
) have been moved tokernel/funrecmeta.{sig,sml}
. This involved minor edits to virtually all files in FLINT and a few in CPS. Seedev-notes/FLINT
for further documentation. -
Bug #294 (Compiler bug: Recover) has been fixed by deleting a few lines of code in
FLINT/opt/fcontract.sml
. Filesopt/collect.sml
andopt/fcontract.sml
been "clarified" to make them somewhat easier to maintain/debug. -
The
VarCon:VARCON
structure defined inElabData/syntax/varcon.{sig,sml}
has been renamed Variable: VARIABLE (ElabData/syntax/variable.{sig,sml}
), since it no longer contains functionality relating to data constructors. -
The regression tests (
$smlnj/tests
) were run and a few true regressions were fixed, including a type error (bugs/tests/bug0573.sml
). Many regression failures remain that are due to differences in the pretty printers, reworded error messages, and new printing conventions for overload scheme type variables. Some reference test outputs were updated, but at some point all new outputs should be generated. But first, signature printing should be redesigned and reimplemented.
-
- [2021/09/23]
-
Changed the binfile representation to remove the pickling of the FLINT intermediate representation. The purpose of this mechanism was to support cross-module inlining, but it has not be enabled for many years. Removing it is the first step toward migrating the pickling infrastructure to use ASDL.
- [2021/09/23]
-
Changed the way that versions are identified to allow a version suffix (e.g., "-rc1" for "release candidate 1"). I removed the bump-release mechanism, which might has served a similar purpose, but was restricted to integer suffixes and has not been used in recent memory. Also changed the
SMLNJVersion
structure, which is generated by theversiontool
. The new interface supports the version suffix and includes both a build date and a release date in theversion
information record.
Version 110.99.2; 2021/09/23
- [2021/08/18]
-
Fix a benign bug where the size of a floating-point spill record was twice as large as necessary on 64-bit systems.
- [2021/08/10]
-
Split out the
Real.toLargeInt
implementation into target-word-size versions (theReal64ToIntInf
module). For 64-bit targets, the new version uses the bit representation of the real number to compute the result. The 32-bit version is the old code that uses floating-point operations. This change fixes bug #279 (Real.toLargeInt
returns zero for anything in range[-512,512]
).
- [2021/04/29]
-
In the translation from Absyn to PLambda, there was a function (
inlops
) that was used to build the primop and type data structures for numeric types. This function was being called for every primitive operator, even though its results only depended on the numeric type. I added a hash table to cache the results indexed numeric kind. This change speeds up the compiler by about 3% (e.g., compiling the compiler went from 58s to 55s on a MacBookPro with a 2.4GHz Intel i9 processor).
Version 110.99.1; 2021/04/12
- [2021/04/10]
-
Changed the AMD64 frame layout to include a word to hold the
Overflow
exception. This value is used by the LLVM backend to generate the exception for checked arithmetic operations.
- [2021/04/10]
-
Added support for running SML/NJ on M1 Macs via the Rosetta2 emulator. The change is to identify the arm processor as amd64 in the
config/_arch-n-opsys
script. Note that while the system basically seems to work okay under rosetta, trying to run themakeml
command after having compiled the complier caused a crash.
- [2021/04/10]
-
Some minor restructuring of the logic in the generic installer.
- [2021/03/25]
-
Fixed a bug with how FLINT numeric types were being translated to CPS types. Specifically, types that were smaller than the default integer size (e.g.,
word8
) should have been marked as having a tagged representation.
- [2021/02/12]
-
Fix for bug #280 (110.99
config/install.sh -64
fails on macOS 10.15.7). I was unable to reproduce this problem, but after some investigation, it appears that the problem was inconsistent build tools being picked up from the user’s path. To protect against this issue, I made the paths to the ar and ranlib tools absolute.
- [2021/01/12]
-
Fixed a serious performance bug in the implementation of the
CharBuffer
andMonoBuffer
structures. Essentially, if one did not reserve sufficient space for the contents, it could take quadratic time to fill the buffer. We now grow the buffer by a factor of 1.5 of its current size, with an upper bound on the extra growth of 256K.
Version 110.99; 2020/12/24
- [2020/12/23]
-
Changed the layout of the SML stack frame on the AMD64 architecture to make it compatible with the way that LLVM spills registers. Essentially, this just involved swapping the order of the swap area and the ML stuff. We took this opportunity, however, to localize up the representation of this information in the compiler.
- [2020/12/23]
-
Changed the format of the "magic string" in the header of binfiles. The new format is "arch
-
version", where the architecture name is limited to at most seven bytes and the version is limited to at most eight bytes. The string is padded with spaces to a total length of 16 bytes.
- [2020/12/22]
-
Various pretty-printer bug fixes:
- [2020/12/19]
-
Fixed bug #254 (
Real.fromLargeInt
produces negative results). The problem was because the digit size forIntInf.int
is only one bit smaller than the default int and the scaling factorrbase
was being computed using theInlineT.Real64.from_int
function (sorbase
ends up being negative). Thus it would return incorrect results whenever the IntInf representation involved more than one digit. This is a bug on both 32-bit and 64-bit systems. The fix was to switch to usingInlineT.Real64.from_int{32,64}
to convertrbase
and digits to real values.
- [2020/12/19]
-
Fixed bug #267 (Returns an incorrect result for a calculation on
Position.int
for 32-bit mode). The problem was that on 32-bit machines, 64-bit division is implemented by the IntInf module with the result then being converted to 64-bits. The conversion used did not test for overflow in the result.
- [2020/10/13]
-
Changed the semantics of the spans returned by ml-ulex so that the second component of a span is the position of the rightmost character in the token (instead of the character following the token). Specifically, the span \((p_1, p_2)\) specifies the \(p_2 - p_1 + 1\) characters that start with the character at position \(p_1\) and run to \(p_2\) (inclusive). This change avoids a potential problem when the span of a token ends at the last character in a file (when the input is spread across multiple files).
- [2020/09/10]
-
Simplified the binfile representation by removing the option of having multiple code objects. Many years ago, we would split the code for a compilation unit into multiple independent functions so that the garbage collector could reclaim code that was only executed once (or was not referenced). The actual splitting of the code in the
CpsSplitFun
functor (CPS/clos/cps-split.sml
) was replaced by a dummy implementation at some point, so we have not been generating multiple code objects for some time. Therefore, we have simplified the code generator to assume only one code object and have changed the binfile import/export code to only support a single code object per binfile.Also made this change to the bootstrap loader (
kernel/boot.c
).
Version 110.98.1; 2020/08/25
- [2020/08/25]
-
Reverted some of the pretty printing changes that were made in 110.98 to the 110.97 version (the renaming of
PrettyPrintNew
toPrettyPrint
and the directory reorganizations were unchanged). These changes fix bugs #266 (Pretty printing regression in SML/NJ 110.98), #268 (Polymorphic Type Pretty Printing Regression), and #271 (pretty printer regression for structure binding).
- [2020/08/02]
-
Fixed bug #269 (
Word64.fromString
causes anOverflow
for greater than 232-1). This bug was the result of constants from the 32-bit version of the code not getting updated for the 64-bit version. Scanning of both hexadecimal and octal representations of both integers and words were affected.
- [2020/07/22]
-
Added an additional lowering pass for the
STREQL
primop. This primop is generated to implement pattern matching against string literals. Previously it was unrolled in the MLRISC code generator, but we now do the unrolling in CPS. The reason for this change is that implementing the unrolling in the LLVM code generator would be complicated because of the need to introduce phi nodes in one of the branches.The unrolling in CPS is somewhat different from before in that we now bake the literal string being tested into the equality tests.
Also changed the representation of the primop to include the string being tested against and removed the
STRNEQ
primop.
Version 110.98; 2020/07/16
- [2020/07/10]
- [2020/07/10]
-
Changed the
config/install.sh
script so that the default size is 64 bits for any machine that reports its machine as "x86_64
."
- [2020/07/10]
-
Fixed bug #260 (Perform divide on
Position.int
crashes with FPE on Linux). The fix required adding SIGFPE as a second source ofOverflow
exceptions on Linux/amd64 machines.
- [2020/07/08]
-
Fixes for structure and signature pretty printing problems that were introduced in the extensive pretty printer/pretty printing modifications around revision 6291.
Files affected include
ElabData/modules/ppmod.sml
,ElabData/types/pptype.sml
,TopLevel/print/ppdec.sml
, andBasics/print/pputil.
{sig
,sml
}.The pretty printing for modules still seems quite fragile, so there are likely to be more pretty printing problems to be fixed later. In particular, pretty printing of functor and functor signature declarations haven’t been tested.
- [2020/07/07]
-
Added a new lowering pass following CPS optimization, but before closure conversion. This pass includes the previous passes for 64-bit operations on 32-bit matchines and for conversions involving
IntInf.int
. It also adds lowering fordiv
andmod
to native machine division (i.e.,quot
andrem
) and for trapping conversions.The purpose of this change is to simplify code generation in preparation for migrating to a LLVM-based backend.
- [2020/07/06]
-
Fix for bug #261 (Weird "calc_strictness" message being printed). Rewrote the function
ElabUtil.calc_strictness
and moved it toTypesUtil.calcStrictness
.
- [2020/07/02]
-
The
HTMLDev
structure in the pretty-printing library has been moved into its own library (pp-extras-lib.cm
) and renamed asHTML3Dev
. This change removes the dependency ofpp-lib.cm
onhtml-lib.cm
, which allowed us to remove all mention ofhtml-lib.cm
from the compiler CM files.
- [2020/07/02]
-
Completed the removal of the trigonometry operators from the primops. This change also allowed the removal of extension support from the MLRISC code generator for the x86.
- [2020/07/01]
-
Disabled the use of the hardware instructions for the basic trig functions on the x86. Doing so simplifies cross compilation from non x86 hosts and also paves the way to removing the operations from the compiler’s primitive operators.
- [2020/06/30]
-
Improved the CPS contraction phase by adding strength-reduction optimizations to
ContractPrim
. These include recognizing when multiplications and divisions by powers of 2 can be replaced by shifts. Previously, these sorts of optimizations were provided by MLRISC, but we plan to simplify the CPS IR prior to code generation by replacingdiv
andmod
operations with native machine arithmetic, which would prevent MLRISC from making the optimizations.
- [2020/05/16]
-
The MLRISC instruction selector for the x86 and amd64 targets erroneously assumed that the
idiv
instruction sets theOF
(overflow) condition code when dividing the largest negative number by~1
. In fact, such a division operation traps, which is okay, because the runtime system maps the trap to theOverflow
exception. Since the check for overflow is unnecessary, it has been removed from the filesMLRISC/amd64/mltree/amd64-gen.sml
andMLRISC/x86/mltree/x86.sml
.Note that MLRISC's non-trapping signed division operations can actually trap on overflow, but this was true before this change.
- [2020/05/16]
-
Changed the semantics of the
--debug
command-line option for ml-antlr. Previously this option replaced the actions with a print expression, but that limited its usefulness because of type errors in the generated code. The new behavior is to preserve the existing actions and just add the printing code.
- [2020/04/27]
-
Added a pass to the elaborator that check for variables that are bound, but never referenced. This check can be controlled by the
Control.Elab.unusedWarn
flag. Unused top-level variables are not reported (unless they are bound in the local part of a local declaration).The check is currently disabled because of false positives caused by a transformation in the type checker. For example, the following function declaration:
fun foo n = let fun f x = g x - 1 and g x = f x + 1 in f n end;
gets represented by the following
Absyn
:val foo = let val foo = (fn n => let local val tmp = let val rec f = (fn x => Int.- (g x,1)) and g = (fn x => Int.+ (f x,1)) in (f,g) end in val f = #1 tmp val g = #2 tmp end in f n end) in foo end
where the instance of
g
bound to#2 tmp
is unused. This transformation is done by thewrapRECdec
function. The unused-variable implementation was influenced by Jacob Van Buren’s patch for Version 110.82.
- [2020/04/24]
-
The
LambdaVar.lvar
type is represented as an integer; since the earliest days of the compiler this representation has been concrete, which meant that the type system was not able to provide any guarantees thatint`s and `lvar`s were not being mixed up. As of this change, `LambdaVar.lvar
is now an abstract equality type (internally, it is still andint
). Some comments about the changes:-
The
LambdaVar
structure now includes substructures that implement hash tables (LambdaVar.Tbl
), finite maps (LambdaVar.Map
), and finite sets (LambdaVar.Set
). -
most of the changes involved replacing
IntHashTable
,IntRedBlackSet
,IntRedBlackMap
with the equivalent substructures that were added to theLambdaVar
structure (e.g.,IntHashTable
=⇒LambdaVar.Tbl
). -
there were a few place where debugging code assumed that lvars could be printed as integers.
-
the pickling code requires a mechanism to convert between integers and lvars; this is the one place where the abstraction is broken.
-
the worst abuse of the fact that the lvar type was
int
was in the code generator, where arithmetic was used to generate a unique negative number that could be used as a hash key, so that a givenlvar
could be mapped to two different labels. I fixed this by using two tables.
-
- [2020/04/24]
-
Fixed bug #256 (
Ref.exchange
incorrect). The original source of the bug was the Basis Library sample code, which has also been fixed.
Version 110.97; 2020/04/21
- [2020/04/21]
-
Changed the printing of tyvars; e.g., an
OVLDV
tyvar introduced by an occurrence of the overloaded operator "*" that also acquires the equality attribute will be printed as ''Z[OL(*)].
- [2020/04/20]
-
Eliminated AbsDec and ABSdec constructors
-
Eliminated
AbsDec
constructor inParse/ast/ast.
{sig
,sml
} andABSdec
constructor inElabData/syntax/absyn.
{sig
,sml
} The "abstraction" declaration that these constructors implemented was in SML/NJ 0.93, but was eliminated in favor of opaque "sealing" signature ascription after SML '97. -
Eliminated all other occurrences of these constructors throughout the compiler (Front End, FLINT, and cm).
-
- [2020/04/20]
-
File structure reoganization: the top-level
compiler/Semant
directory was eliminated. Remaining relevant subdirectories wereSemant/pickle
, which moved toElabData
, andSemant/prim
, whose two files,prim-env.sml
andprimop-bindings.sml
moved to the existingElabData/prim
directory. CM filescompiler/core.cm
andElabData/elabdata.cm
changed accordingly.
- [2020/04/20]
-
Fixed bug #220
-
Major redesign of the overloading resolution mechanisms. Changed syntax of overload declaration (partly deferred to 110.98). Changed OVLDvar in VarCon.var, added files overloadclasses.sml and overloadvar.sml to Elaborator/types. Changed Types.tvKind in ElabData/types/types.{sig,sml}, splitting OVLD tvKind into OVLDV (overloaded variables/operators), OVLDI (overloaded int literals) and OVLDW (overloaded word literals). Modified treatment of the overload metavariables in Unify (Elaborator/types/unify.sml).
-
Changed printing of overload type metavariables (unification type variables (
Types.tyvar
)). -
Files:
ElabData/types/types.
{sig
,sml
}ElabData/types/overloadclasses.sml
(new)ElabData/types/overloadvar.sml
(new)ElabData/types/overload.sml
Elaborator/elaborate/elabcore.sml
-
- [2020/04/09]
-
Fixed bug #214
-
Changed printed message when a VALvar binding is shadowed to print “<hidden>” (function
ppVar
inMiscUtil/print/ppdec.sml
). -
Minor cleanup of
dontPickle
function inSemant/pickle/pickmod.sml
.
-
- [2020/04/08]
-
Fixed bug #209
-
Added function
checkForbiddenCons
toElabUtil
(Elaborator/elaborate/elabutil.{sig,sml}
) that checks if a symbol is in the forbidden constructor set (it
,true
,false
,nil
,::
, andref
). -
Modified
elabEXCEPTIONdec
to check for forbidden exception constructor names. Rewrote functionelabEb
to simplify. -
Added a test for forbidden constructor names in function
elabConstr
withinelabDB
. -
Changed specs for types list and bool to datatype replication specs in
system/Basis/Implementation/{list,bool}.sig
to avoid an error caused by the occurrence of "forbidden" constructors.
-
- [2020/04/07]
-
Some clean up in the
ml-lex/lexgen.sml
code. Replaced the one-off implementation of finite maps with theRedBlackMapFn
functor from the SML/NJ Library. Also got rid of the uses of polymorphic equality by changing token equality tests to pattern matching.
- [2020/04/05]
-
Turned several functors (
ElabModFn
,ElabTopFn
,SigMatchFn
, etc. into structures and removed the redundant functor application files (and the directories) inSemant/elaborate
andSemant/modules
.
- [2020/04/05]
-
- [2020/04/02]
-
Various minor changes related to the heap2exec and heap2asm programs.
-
Modified the
config/install.sh
script to removebin/heap2exec
when the required helperbin/heap2asm
is not installed. -
Added
-static
and-dynamic
as options to heap2exec (these are the same as--linkwith-a
and--linkwith-so
) -
Rewrote heap2asm be a bit more future-proof.
-
- [2020/04/02]
-
Addressed bug #247 (@SMLVersion should report 64/32 bit) by adding a new command-line option (
@SMLwordsize
) to the.run-sml
command script. Specifying this option will cause the the wordsize to be printed (either32
or64
) and then the program will exit.
- [2020/03/19]
-
Fix for bug #252 (Boyer Benchmark Compile Failure). This crash was caused by a typo in the
CPS/main/build-literals.sml
code that caused an incorrect opcode to be generated forSAVE
/LOAD
instructions when the offset was>= 256
.
- [2020/03/04]
-
Fixed the calculation of the maximum array/vector length for 64-bit targets. We had been using the calculation for 32-bit targets.
- [2020/01/14]
-
Fix for bug #245 (Lazy data types result in Compiler Bug error). The problem was that a number of symbols (e.g.,
deref
) had been dropped from the_Core
structure, but were required to support the lazy (and profiling) features in the compiler. The symbols have been reinstated and a comment has been added to explain why they are being included.
- [2019/12/23]
-
Fix for bug #244 (Compiler bug: PPObj: ppFields in ppval.sml). The code generator was using the wrong length tag for raw64 records on 64-bit machines (twice the length).
- [2019/12/21]
-
Clean up various issues in the configuration/build machinery for asdl. This includes a fix for bug #240 (Non-default 64-bit installation build failure)
- [2019/12/18]
-
Fix bug #239 (
Date.toTime
is incorrect (by a factor of 10E9)). Thanks to Johannes 5 Joemann for both the report and fix.
Version 110.96; 2019/12/13
- [2019/12/12]
-
Bug fix for a problem where ^C (and other signals might be ignored). The fix is to use word-sized fields in the VProc state vector so that the word-sized move operations in the assembly code do not clobber adjacent fields.
- [2019/12/12]
-
Fix for bug #234 (Converting NaN to a string causes an infinite loop on 64-bit machines). The problem was in
MLRISC/amd64/mltree/amd64-gen.sml
, which was not generating comparisons that work correctly when the arguments are unordered.
- [2019/12/12]
-
Removed assertion checking from the amd64 runtime makefiles. It has not turned up any errors since 110.94 was released, so we will assume that things are working the way that they should.
- [2019/12/01]
-
Bugfix for bug #237 (heap2exec script fails on 110.95). The fix was provided by Kirill Boltaev.
- [2019/11/23]
-
Changed the default installation size to 64 bits on macOS 10.14 Mojave and later.
- [2019/11/14]
-
Fixed some code rot in the eXene sources (bug #233). With the
LargeWord
module changing fromWord32
toWord64
, there were a few places were things broke.
- [2019/11/14]
-
Added support for 64-bit executables on FreeBSD. As part of this effort, we fixed a couple of regressions (makefile issues) for the 32-bit version on FreeBSD that were introduced when the
X86.prim.asm
file was rewritten. We also switch from BSD signal handling to POSIX signal handling, since that is what we use for most other systems.
- [2019/11/10]
-
Many years ago, SML/NJ had a bytecode interpreter, but it was mostly removed from the system a long time ago. There were, however, some remnants of it in the runtime system. These have now been removed.
Having made this change, the distinction between the "target" and "host" architectures is no longer necessary. Therefore, these have been merged into a single architecture property. The effects of this merge are as follows:
-
the
TARGET_xxx
andHOST_xxx
C-preprocessor symbols have been replaced with a singleARCH_xxx
symbol in the runtime system. -
The
SMLofNJ.SysInfo
structure now providesgetArchName
andgetArchSize
functions. -
The following
SMLofNJ.SysInfo
functions are deprecated and will be removed in 110.97:getHostSize
,getHostArch
, andgetTargetArch
.
-
Version 110.95; 2019/11/09
- [2019/11/09]
-
Fix for bug #230 (New literals-lifting code does not handle pair of reals).
- [2019/11/09]
-
Simplified the runtime-system build rules for Cygwin.
- [2019/11/08]
-
Created the script
config/prepare-win-install.sh
, which implements the fetching and unbundling of source and bin files in preparation for a Windows installation.
- [2019/11/07]
-
Fix for bug #229 (
Real.fromString
errors). This bug was actually two unrelated issues. The problem thatReal.toString
returnsReal.posInf
for0.0e123213213123213123123
has been fixed in theRealScan
module (system/basis/Implementation/real-scan.sml
). The second bug was a regression introduced in 110.93, where theSIGFPE
signal was specified as the result of theinto
instruction, whereas Linux actually signalsSIGSEGV
forinto
. Note that there may be a related issue of BSD systems, whereSIGBUS
might be the signal, but we need access to a test machine to verify.
- [2019/11/07]
-
Fix for bug #230 (segmentation fault when compiling MLton sources with SML/NJ 64-bit). The problem was that when a large vector was being created, the assembly code did not correctly restore the stack state before trying to call the runtime system to do the allocation.
- [2019/11/04]
-
The runtime now uses
MAP_ANON
for allocating memory on 64-bit Linux. This change fixes a problem with versions of Linux that do not allow access to/dev/zero
(such as on ChromeBooks).
Version 110.94; 2019/10/31
- [2019/10/23]
-
Modified the generic installed (
base/system/smlnj/installer/generic-install.sml
) to support conditional targets. You can now write tests likeif UNIX unix-utils endif
The symbols that can currently be tested for are
SIZE_32
,SIZE_64
,UNIX
, andWINDOWS
. See theconfig/targets
file for more details.
- [2019/10/23]
-
Fixed bug #227 (CPS contraction is taking an excessive amount of time on word8 basis test).
- [2019/10/22]
-
Modified the CPS contraction phase to optimize the case where a numeric conversion is applied to a constant value.
- [2019/10/21]
-
Modified the Unix installer script (
base/system/smlnj/installer/nix-install.sml
) to pass a size argument to the configuration script. This argument is used by the ASDL configuration.
- [2019/10/21]
-
Overhauled the installation script (
config/install.sh
) and various script templates (e.g.,config/_run-sml
) to allow setting the default size. Theconfig/install.sh
script now supports the following arguments:- -default size
-
specify the default size for the sml and other commands, where size is either 32 or 64.
- -32
-
install the 32-bit version of the system.
- -64
-
install the 64-bit version of the system.
It is possible to install both versions in the same location by running the
install.sh
script twice. For example, the commands% config/install.sh -32 % config/install.sh -default 64
will install both versions with the 64-bit version as default. One would then use the command sml -32 to run the 32-bit version of the system. Note that the default version must be installed second.
- [2019/10/21]
-
Added support for the -64 flag to the
fixpt
script inbase/system
.
- [2019/10/17]
-
Added support for the -64 flag to the
cmb-make
script inbase/system
.
- [2019/10/17]
-
Renamed the
REAL
representation constructor toRaw64
, which matches what is going on in the runtime system. Also renamed thetoReal
function totoReal64
.
- [2019/10/15]
-
Updated the
SMLofNJ.SysInfo
structure by removing constructors from theoskind
datatype that correspond to obsolete systems. Also added agetHostSize
function that returns the host architecture’s native word size in bits (e.g., 32 or 64).
- [2019/10/13]
-
Added the -64 flag to the
testml
script inbase/system
and to the.run-sml
script. Thus, one will be able to specify the 32-bit version of SML/NJ using the command sml -32 and the 64-bit version using the command sml -64. Currently, 32-bits is the default, since the 64-bit system is unstable.
- [2019/10/13]
-
Removed obsolete operating systems from the
SMLofNJ.SysInfo.os_kind
datatype. This change reduces the type to two constructors:UNIX
andWIN32
. Also added a functiongetHostSize
to theSysInfo
structure, which returns the host word size in bits (i.e., either32
or64
). The word size is now reported in the compiler’s banner message at startup.
- [2019/10/12]
-
Fixed bug #130 (failure to raise
Bind
exception). Added a functionrefutable
toElabData/types/typesutil.{sig,sml}
and used it to limit type generalization of val bindings inElaborator/types/typecheck.sml
. The fix does not deal properly with refutability of OR patterns, but OR patterns in val bindings is a dubious feature.
- [2019/10/04]
-
Modified the cmb-make script to support passing compiler control flags to the build command. The flags should be specified after the path to sml command (if it is given).
- [2019/10/04]
-
Finished the implementation of the new literal bytecode engine. There is a control flag (
Control.CG.newLiterals
that allows switching between the old and new bytecodes).
- [2019/10/04]
-
Fix for bug #225 (
Math.ln
giving erroneous answers on Windows). The problem was an inconsistency in the way the Unix and Microsoft assemblers interpreted the addressing mode for theFLD
instruction.
- [2019/10/03]
-
Clean up in the Basis Posix library code (both SML and runtime) to be consistent about when the
SysWord.word
type is being used to communicate information between SML code and the runtime system.
Version 110.93; 2019/09/05
- [2019/09/04]
-
Add support for specifying a 32 or 64-bit target as command-line option to the
.arch-n-opsys
and.link-sml
scripts. The default size is currently 32-bits, but that will change once 64-bit support is solid.
- [2019/09/03]
-
Generalize code generation for conversions involving tagged integers/words, where the size is not the default integer size. This situation only occurred for
Word8.word
values on 32-bit targets, but also occurs for 32-bit values on 64-bit targets.
- [2019/09/02]
-
Rewrote the expansion of the
INLLSHIFT
,INLRSHIFTL
, andINLRSHIFT
primops (compiler/FLINT/trans/transprim.sml
). The expansion process now correctly handles shift operations on types that are smaller than the default tagged-integer size. This change also allows theWord8
shift operations to be inlined.
- [2019/09/02]
-
Fixed a bug in the constant folding of arithmetic-right-shift operations. The sign was not getting extended for words when the most-significant-bit was set.
- [2019/08/25]
-
Fixed a bug in the
Real.toManExp
function (the exponent was off by one, which meant that the mantissa was two times its expected value). This fix also fixes a problem inReal.toLargeInt
, where the function would go into an infinite loop in some cases.UPDATE2022/06/29This change probably also fixed bug #208 (
Real.toManExp
produces incorrect results in some cases).
- [2019/08/24]
-
Fixed bug #173 (
OS.Process.sleep
only works with whole numbers). For systems that have finer-grain sleep function, such as thenanosleep
(2) system call, theOS.Process.sleep
andPosix.Process.sleep
functions now support sub-second granularity.
- [2019/08/18]
-
Restructured the CPS contraction phase to make the fusion of integer/word conversions more uniform. Also fixed a bug where
Int32.fromLarge(Word32.toLargeInt 0wxffffffff)
would return~1
instead of raisingOverflow
. The problem was thatTEST(m,n) o COPY(n,p)
was getting fused toCOPY(m,p)
whenm = p
, instead ofTRUNC(m,p)
.
- [2019/08/14]
-
Int64 comparisons were not always correct, which lead to some positive values being printed as negative numbers (basically when the sign bit of the lower word was set).
- [2019/08/13]
-
Added
Unsafe.IntInf
structure, which provides access to the internal representation of theIntInf.int
type. Note that this representation may change in the future.
- [2019/08/12]
-
Fixed bug #223 (Incremental Build fails on Windows). There was a missing
CloseHandle()
when getting a file’s timestamp.
Version 110.92; 2019/08/10
- [2019/08/08]
-
Changed
base/system/allcross
script to usecmb-cross
script. Also modified thecmb-cross
script to build compressed tar files, when given the-z
option, and to clean up intermediate files.
- [2019/07/16]
-
Restructured the amd64 machine-code generation implementation and filled in many of the missing encodings. It should be complete for SML/NJ code generation, but needs more work to support the full set of operations described in the
amd64.mdl
file.
- [2019/07/16]
-
Some cleanup in the x86 MLRISC backend. Removed the
MULB
,MULW
, andMULL
unsigned-multiplication instructions, since they are not binary operations. TheMULL
instruction is covered by theMULL1
constructor in themultDivOp
datatype. The same change was applied to the amd64 backend.
- [2019/07/15]
-
Many changes to the amd64 machine description:
-
Removed the
PUSHB
,PUSHW
, andPUSHL
instructions, since the matchingPOP
operations are not supported. -
Removed the
CALLQ
operation, since it is the same asCALL
. -
Removed the
CLTD
andCQTO
operations, since those names are just synonyms forCDQ
andCDO
. -
Replaced the
INTO
operation (which is not valid in 64-bit mode) withINT of byte
.
-
- [2019/07/13]
-
New script for cross compiling to other architectures; the script is still called
cmb-make
, but now supports target-specific dependencies in the front-end (i.e., representation of numeric types and endianess). The cross compilation scheme was developed by Matthias Blume and then encoded in a script.
- [2019/07/11]
-
The runtime system now builds for the amd64 architecture. Most of the changes relate to the difference between the flat BIBOP on 32-bit platforms and the two-level BIBOP on 64-bit platforms.
- [2019/07/09]
-
Fix bug #224 (
Word64.fromLargeInt
fails). The problem was an incorrect record kind inCPS/opt/infcnv.sml
(it wasRK_RECORD
instead ofRK_RAWBLOCK
).
- [2019/07/08]
-
Changed the
rep
datatype constructorWord32
toRaw
(which covers both 32 and 64-bit numbers on 32-bit platforms). We now check the length of the raw object when converting to an concrete numeric type.
- [2019/06/28]
-
Removed the use of runtime-type passing for polymorphic arrays. The effect of this change is that code that uses the
Array.array
type will be faster when the element type is notreal
(e.g., sorting anInt32.int array
was 1.2 times faster), but slower when the type isreal
. Use the monomorphic typeRealArray.array
for best performance on arrays of reals.
Version 110.91; 2019/06/20
- [2019/06/20]
-
We added a new primop,
REAL_TO_BITS
that casts a floating-point value to the same-size word value. This primop allows the Assembly.logb function to be implemented in SML.We have also refactored the implementation of the
Math
structure to share common code across the versions that are specialized for different levels of hardware support.
- [2019/06/19]
-
Rewrote the assembly code for the x86 and AMD64 targets. Previously, there were separate source files for Unix and Windows; these have been replaced by a single common file (one for each architecture). The
assyntax.h
file has also been replaced byx86-syntax.h
, which covers both the x86 and AMD64 on both UNIX and Windows.The
AMD64.prim.asm
file now compiles, although there are a few minor issues that will have to be fixed once we have a working code generator. We have also fixed a number of issues in the garbage collector related to the use of the 2-level BIBOP on 64-bit targets.
- [2019/06/18]
-
Some cleanup in the interval-timer code. In keeping with the other time-specific functions, I have switched the runtime-system API to use unsigned 64-bit nanoseconds to specify time values. I have also added an implementation for
c-libs/smlnj-runtime/itick.c
, which was missing. Lastly, moved the Windows-specific filewin32-timers.c
fromruntime/kernel
toruntime/mach-dep
.
- [2019/06/16]
-
Added 64-bit implementations of the target-specific Basis Library modules in directory
Basis/Implementation/Target64Bit
.
- [2019/06/16]
-
Added
PackWord64Big
andPackWord64Little
structures to Basis Library. Note that the implementation of these is target-specific.
- [2019/06/16]
-
Added
bigEndian
flag to theTARGET
signature.
Version 110.90; 2019/06/12
- [2019/06/12]
-
Fixed the Concurrent ML library to use 64-bit positions (both Unix and Windows) versions.
- [2019/06/11]
-
Moved the year offset from SML to the runtime system. This change is necessary because Windows uses 1601 as year 0, whereas UNIX uses 1900. We have also switched to using unsigned 64-bit times in nanoseconds as the interface between the Basis code and runtime system. This change is consistent with the other places where time values are communicated between the runtime and SML code.
- [2019/06/07]
-
Fixed a problem with CM’s symbol filtering (see bug #222).
The problem could manifest itself when a library
l2.cm
imported two symbolsA
andB
froml1.cm
and then exported the sameA
but a differentB
(which could have been defined in terms of the importedB
). Moreover, for the problem to occur bothA
andB
withinl1.cm
must have come from the same SML source file.With the above setup, when running
CM.make "l2.cm";
it was possible that instead of seeing the new A
defined within
l2.cm
one would still see the original version that came from
l1.cm
.
- [2019/06/04]
-
Various 64-bit porting changes to the Windows implementation of the Basis Library and runtime system:
-
Add a target-specific
Handle
structure to support theHANDLE
type, which is a pointer-sized word value. -
Changes to support the use of 64-bit file positions.
-
Replaced pairs of argumnents representing time values (seconds and microseconds) with a single 64-bit count of microseconds.
- [2019/06/04]
-
Implemented Basis Library proposal 2019-001 (Correction to the PRIM_IO signature). This proposal changes the return type of the
avail
function in a reader to bePosition.int option
, which is necessary to support large files.
- [2019/06/03]
-
Added primop support (
PTR_TO_WORD
andWORD_TO_PTR
) for thec_pointer
type that was added in 110.89. These primops are exposed in the newInlineT.Pointer
structure. We define aPointerImp
structure that is used inside the Basis implementation and aUnsafe.Pointer
structure that is visible to users.
Version 110.89; 2019/06/01
- [2019/06/01]
-
Added abstract
c_pointer
type to the primitive types. This type will be used to represent runtime-system pointers (e.g., theHANDLE
values in the Windows implementation).
- [2019/05/31]
-
Removed makefiles and code for architectures and operating systems that are no longer supported (e.g., the DEC Alpha and HPPA architectures).
- [2019/05/31]
-
Switched the
FixedInt
andLargeWord
structure aliases to be 64-bits (i.e.,FixedInt
is now bound toInt64
andLargeWord
is bound toWord64
).
- [2019/05/30]
-
We are now assuming that we have at least C99 support (for practical purposes, this assumption is even true on Windows). With this assumption, the allocation of small objects in the runtime has been switched from macros to inline functions (see
runtime/include/ml-objects.h
). This change allows a graceful handling of 32-bit integers, which are heap allocated on 32-bit machines, but tagged on 64-bit machines.
- [2019/05/29]
-
Fixed various bugs in the implementation of the
Word64
operations. The addition and subtraction operators were using arithmetic right shifts, instead of logical right shifts. Also, the translation of 64-bit shift operations was incorrect because of a typo in the variable names.
- [2019/05/27]
-
Created a simplified version of the
MLRiscGen
functor. This version of the functor, which is in the fileCodeGen/main/mlrisc-gen-fn.sml
does not include the memory disambiguation and GC types code. Since the old version (CodeGen/main/mlriscGen.sml
) did not use these features by default, there should be no difference in the quality of the generated code.The purpose of this change is to remove unused code that has 32-bit dependencies.
- [2019/05/25]
-
Added contraction for unsigned
REM
andNEG
operations inCPS/opt/contract-prim.sml
.
Version 110.88; 2019/05/15
- [2019/05/15]
-
Moved the
compiler/DEVNOTES
directory to thedev-notes
tree and renamed itold-compiler-notes
.
- [2019/05/15]
-
Added 64-bit versions of
NumFormat
andNumScan
. We use the 32-bit version for numbers of 32-bits or less and the 64-bit versions for numbers with up to 64 bits. Thus, on 32-bit machines, the defaultint
andword
types useNumFormat32
andNumScan32
, while on 64-bit machines they useNumFormat64
andNumScan64
. This change also required splitting out some common code into aScanUtil
structure and also splitting out the scanning of real numbers into theScanReal
structure (formatting of reals was already in its own structure).
- [2019/05/15]
-
Reimplemented the 64-bit
int
andword
types to put them on a (mostly) equal footing with the other precisions. In this new implementation, the basic typesint64
andword64
are nowPRIMITIVE
(instead of beingABSTRACT
type represented by pairs of boxed 32-bit words). Arithmetic and comparison operations on these types are represented as primops and are preserved as such up to just before closure conversion. At that point, the newNum64Cnv
structure (compiler/CPS/opt/numcnv.sml
) is used to expand 64-bit operations and constants into 32-bit operations. Most of the 64-bit primops are inline expanded, but multiplication and division operations are converted to calls to library code from theCoreInt64
andCoreWord64
modules (system/smlnj/init
).Because the type are primitive, we were able to change the runtime representation to use packed records (
RK_RAWBLOCK
) to represent them, which saves space and should also help with performance.See the
dev-notes/num64.md
file for more details about the implementation.
- [2019/05/09]
-
Reorganized the Basis Library source files (
system/Basis
) to isolate dependences on target word size.In the
Basis/Implementation
directory, I created subdirectories (e.g.,Target32Bit
) to hold implementations that are specific to the target. These directories include abind-structs.sml
file that replaces the manybind-*.sml
files inBasis/Implementation
.In the
Basis/Exports
directory, I replaced the many individual files (each with a single module renaming) withbind-common.sml
(for target-independent bindings) and a target-specific file (eitherbind-target-32-bit.sml
orbind-target-64-bit.sml
).
- [2019/05/05]
-
Some of the CPS optimization modules (
Expand
andEtaSplit
were written as functors over the machine spec, when, in fact, they never reference their functor argument. Therefore, they have been converted to structures.
- [2019/05/04]
-
We now use the
InlineT.identity
primop forFn.id
, so the compiler can optimize it.
- [2019/05/03]
-
Fixed pretty-printing regression in 110.87; value of
char
type were missing their enclosing quotes.
Version 110.87; 2019/05/03
- [2019/05/03]
-
Made the
Char.chr
operator inline (a primop was added to support this change in 110.86).
- [2019/05/03]
-
Major renaming of the primitive operators in the
Inline
structure (as described indev-notes/primop-list.md
). Also cleaned up the Basis Library implementation to remove most (but not all) 32-bit dependencies.
- [2019/05/03]
-
Added cases to the top-level pretty printer to handle the new basic types that were added in 110.86 (e.g.,
word8vector
andchararray
). Also changed the way that primitive types are handled to use a table keyed by tycons, instead of a sequence of nested conditionals.
Version 110.86; 2019/05/02
- [2019/05/01]
-
Added
word8vector
andchararray
to the primitive types that the compiler knows about. These will be used in the rewriting of theInlineT
structure.
- [2019/05/01]
-
Replaced the
Primop.primop
constructorsNUMSUBSCRIPT
andNUMUPDATE
with`sml | NUMSUBSCRIPT of numkind | NUMSUBSCRIPTV of numkind | NUMUPDATE of numkind | INLNUMSUBSCRIPT of numkind | INLNUMSUBSCRIPTV of numkind | INLNUMUPDATE of numkind
`This design matches the naming conventions for polymorphic subscripting and updating.
- [2019/05/01]
-
Added
Primop.INLCHR
to implementChar.chr
as an inline function. This change also required moving the definition of theChr
exception to theCore
module so that it is accessible to the translate phase. The inline version of Char.chr will be enabled in the 110.87 release (we need the internal primop before we can use it).
- [2019/05/01]
-
Major overhaul of the representation of primitive operators (both in the
Primop
andCPS.P
structures). The primitive arithmetic and comparison operations are now defined in theArithOps
structure (ElabData/prim/arithops.sml
). There are three datatypes defined in this module-
arithop — integer arithmetic operations that may raise overflow
-
pureop — arithmetic operations that are pure
-
cmpop — comparison operations
These types are used in both the
Primop
andCPS.P
modules, which makes the translation between representations more direct.Some details:
-
inline division and modulo operations were added to the
Primop.primop
datatype; the expansion of these in theTransPrim
module (FLINT/trans/transprim.sml
) adds explicit checks for division by zero. -
the
FSGN
operator was added to thePrimop.primop
datatype, since the newcmpop
datatype does not include it (the CPS IR already had FSGN as a separatebranch
constructor). -
unsigned comparison operations are now represented by using the
UINT
numkind
, which is consistent with how they are represented inCPS
. -
Renamed the primop
ROUND
toREAL_TO_ROUND
. -
the encodings for operators were revised in the pickler, resulting in a more compact use of the numeric codes.
-
- [2019/04/28]
-
Removed unused record kind constructors (
RK_SPILL
,RK_EXN
, andRK_BLOCK
) fromCPS.record_kind
datatype. Also renamedRK_I32BLOCK
toRK_RAWBLOCK
andRK_FBLOCK
toRK_RAW64BLOCK
. Various other renamings to remove 32-bit assumptions.
- [2019/04/28]
-
Renamed
DTAG_raw32
toDTAG_raw
, since the semantics on 64-bit systems will be to require word-size aligned raw data. Also renamedML_AllocRaw32
toML_AllocRaw
andML_ShrinkRaw32
toML_ShrinkRaw
for similar reasons.
- [2019/04/28]
-
Removed unused flags from the
Control
structure; most of these came fromControl.CG
, where roughly 20 out of 60 flags were no longer used.
- [2019/04/27]
-
Split the contraction of primitive operators out of the
Contract
structure into its ownContractPrim
structure.
- [2019/04/27]
-
Split the translation of primops to PLambda out into its own file (
compiler/FLINT/trans/transprim.sml
).
- [2019/04/27]
-
Fixed regression:
Word32.toInt 0wx8002DE32;
would return187954
instead of raisingOverflow
. The problem was a mistake in the way that the overflow trap was being generated inMLRiscGen
.
- [2019/04/26]
-
Some minor primop cleanup.
-
Changed the types of
Primop.ROUND
andPrimop.REAL
to take bitwidths, instead of numkinds, since the kinds are always the same. Also, the fields are now calledfrom
andto
(instead offromkind
andtokind
) to be consistent with other conversion primops. -
Renamed
ABS
toFABS
, since it is only used on floating-point numbers. -
Renamed the CPS primitive operator
ROUND
toREAL_TO_INT
and the operatorREAL
toINT_TO_REAL
. -
Renamed the
Primop.REAL
toPrimop.INT_TO_REAL
so that it is not confused with the other constructors namedREAL
.
-
- [2019/04/23]
-
Improvements to the core 64-bit int and word modules in
system/smlnj/init
. ReplacedInt64.+
,Int64.-
,Word64.+
, andWord64.
with versions from *Hacker’s Delight that use fewer conditional branches. Also replaced the relational operators (<
,⇐
, etc) with more direct implementations.
- [2019/04/21]
-
Fix for bug #213 (
Int32.div
raisesDiv
instead ofOverflow
when dividingminInt
by~1
). Since the compiler generates an explicit test for division by zero, we know that the only arithmetic traps must be caused by other operations. Therefore, we can just map any arithmetic trap toOverflow
.Also removed the old SPARC assembly code for multiplication and division. The code generator always uses the native hardware instructions, so the assembly code is not needed.
- [2019/04/21]
-
Yet another attempt to get the implementation of
use
in the REPL working in a sensible way.With these changes,
use
should behave as follows. If an invocation ofuse
encounters a compilation error (either in the initial file or in a nested invocation ofuse
), then the compiler error message will be printed and the call touse
will immediately return()
. If an invocation ofuse
raises an exception during execution of the compiled code (either in the initial file or in a nested invocation ofuse
), then the exception will be reported at the top-level. Any change to the global state or environment that occurs before an error is encountered, will not be rolled back.Files specified as command-line arguments to the sml command will be treated as if
use
was invoked on them. If there is an error, then the error will be reported and the sml command will terminate with a non-zero exit status (at least on Unix).
- [2019/04/21]
-
Change to the CPS primops: moved the
F_SGN
operator (which is unary) from thefcmp
datatype to thebranch
datatype (and renamed itFSGN
).
- [2019/04/21]
-
Finished conversion of the CPS IR to a form that is compatible with ASDL. Basically, this involved converting the datatype constructor names to upper-case identifiers.
These changes are a step in the plan to eventually switch to an LLVM-based code generator that will be given pickled CPS code as its input.
- [2019/04/08]
-
Starting to migrate the CPS IR toward the ASDL version. Changed the names of the
CPS.P.arith
andCPS.P.cmpop
constructors to be upper-case alpha IDs (many of them were symbolic identifiers). Also split out the various utility functions into the newCPSUtil
module (CPS/cps/cps-util.sml
). Lastly, moved theliterals.sml
file fromFLINT/main
toCPS/main
(where it belongs).Note that the
CPS.P.arithop
datatype is now identical to thePrimop.arithop
datatype
- [2019/04/07]
-
Reorganized the backend of the compiler by moving the CPS-related code into its own directory tree (
Compiler/CPS
) and replacing theFLINTComp
functor with theFLINTOpt
structure and theCPSCompFn
functor. The conversion from FLINT to CPS is part of theCPSCompFn
functor, which takes the program representation all the way from FLINT to machine code segments.
Version 110.85; 2018/12/21
- [2018/12/21]
-
Modified
config/install.sh
to look for a pre-Mojave SDK when trying to install on macOS 10.14 Mojave.
- [2018/12/21]
-
Updated
runtime/objs/cygwin.def
so that the runtime system will build on 32-bit Cygwin. Also updated installation script to suggest using the 32-bit version of Cygwin when a user tries to install it on Cygwin64.
- [2018/11/10]
-
Xcode 10.1, which is Apple’s development environment for macOS 10.14 Mojave, does not include the libraries needed to build 32-bit executables, such as the SML/NJ runtime, although 32-bit programs will still run.
To support building on Mojave, I added a new Makefile (
mk.x86-darwin18
) for the runtime system and modified theconfig/install.sh
script to use this makefile when necessary. This new makefile expects that theMacOSX10.13.sdk
directory from Xcode 9 has been copied into the Xcode 10 SDKs directory. Note that updating Xcode from the AppStore will likely remove the 10.13 SDK, so you should keep a copy in a safe place.The Xcode SDKs live in
Platforms/MacOSX.platform/Developer/SDKs
under theDeveloper
directory. One can determine the path to the current developer directory using the command% xcode-select -p
- [2018/10/10]
-
Removed several unsupported primitive operators from the compiler. In the CPS IR, these were
free
,acclink
,setpseudo
,setmark
, andgetpseudo
. The pseudo-register operations were not supported in the code generator, while the others were no-ops. The corresponding operatorsGETPSEUDO
,SETPSEUDO
,SETMARK
, andDISPOSE
were removed fromElabData/prim/primop.sml
and their bindings were removed fromSemant/prim/primop-bindings.sml
and theInlineT
andUnsafe
structures.The
AllocProf
module in the compiler was also disabled, since it relied on the pseudo registers for recording profile information at runtime. Furthermore, uses of theacclink
primitive operation inFLINT/cps/closure.sml
when static profiling is enabled were removed.These changes were committed as revision 4886.
- [2018/10/08]
-
Fix for bug #216 (run-time system fatal error with large top-level value). The problem was in the code for building literals.
- [2018/09/23]
-
Change CPS operators for wrapping/unwrapping integer and float values to be word-size flexible. We now use a single
wrap
(andunwrap
) operator that is parameterized by anumkind
value. We also changed thewrap
/unwrap
operators tobox
/unbox
. The mapping from old operators to new ones is as follows:wrap
⇒
box
unwrap
⇒
unbox
iwrap
⇒
wrap(INT defaultIntSz)
iunwrap
⇒
unwrap(INT defaultIntSz)
i32wrap
⇒
wrap(INT 32)
i32unwrap
⇒
unwrap(INT 32)
fwrap
⇒
wrap(FLOAT 64)
funwrap
⇒
unwrap(FLOAT 64)
- [2018/09/13]
-
Further cleanup for 64BIT in function
atomeq
inPEqual
. (base/compiler/FLINT/trans/pequal.sml
). AddednumKind
,intEqTy
, anduintEqTy
functions. ThenumKind
function should be extended onceint64
andword64
are treated as primitive types in the compiler.
- [2018/09/12]
-
Fixed 64BIT issue in module
MatchComp
(base/compiler/FLINT/trans/matchcomp.sml
). Addedint64Ty
andword64Ty
cases to functionnumCon
.
- [2018/09/12]
-
Fixed 64BIT issue in module
Equal
(base/compiler/FLINT/reps/equal.sml
). Exports just one function:equal_branch
, which is called once inreps/wrapping.sml
to type-specialize branches on calls toPOLYEQUAL
.
- [2018/09/12]
-
The CPS optimizer had a mechanism for checking the CPS against the FLINT types, which required maintaining a mapping from lvars to their FLINT types. This code has long since bit-rotted and cannot even handle a simple expression like
1+2
. Therefore, I’ve removed the mapping (a hash table) from the CPS optimizer and the vestigial code that modified it in the various CPS optimization passes.
- [2018/09/12]
-
Modified the
InfCnv
(now namedIntInfCnv
) structure to remove 32-bit dependencies.
- [2018/09/11]
-
Modified
Pequal
(inbase/compiler/FLINT/trans/pequal.sml
) andTranslate
(inbase/compiler/FLINT/trans/translate.sml
) to remove 32-bit dependencies. though further changes will be required to properly handleint64
andword64
types whendefaultIntSz
= 64.
- [2018/09/11]
-
Reimplemented the
Switch
module (intbase/compiler/FLINT/cps
). The new implementation follows the same basic design as before, but the code is better organized and documented, and it now uses the concreteCPS
representations, instead of being parameterized over an abstraction of them. It also now uses binary search for boxed (e.g.,Int32.int
) switches.
Version 110.84; 2018/09/03
- [2018/09/03]
-
Reimplemented the array/vector-slice modules to use a (base, start, length) representation (as does Substring in system/smlnj/init/substring.sml). Also fixed a bug in the slice findi functions, where the index being passed to the predicate function was not adjusted to be slice-relative.
- [2018/09/02]
- [2018/09/02]
-
Improved implementation of
CharVectorSlice.map
andCharVectorSlice.mapi
to not build intermediate list of results.
- [2018/08/28]
-
A beta-release of ASDL library and asdlgen tool have been added to the system. This version of the tool implements SML support, but the C++ support is not complete. There is a CM tool for ASDL, which recognizes the
.asdl
file suffix.
- [2018/08/28]
-
Two changes to the installer (
base/base/system/smlnj/installer
):-
The build scripts for programs are now named
build.sh
(instead ofbuild
) on Unix systems. -
The config action has been added to support module configuration.
-
- [2018/08/27]
-
Added
RENAME
extension style to CM tool support. This extension style allows arbitrary file names to be generated from the base name.
- [2018/08/19]
-
Fixed a bug in the implementation of monomorphic buffers: the functions
CharBuffer.add1
andWord8Buffer.add1
had an incorrect length test.
- [2018/06/15]
-
Fixed a compiler bug (
arg ty lists wrong length
) inunifyTy
that could occur when one of the type constructors is theERRORtyc
. This bug occurs because theERRORtyc
is equal to any other type constructor, which (incorrectly) implies that the number of type arguments should be equal.
Version 110.83; 2018/06/01
- [2018/05/29]
-
Fixed #206 (Parsing of explicit type variables and val rec is broken). This bug was also bug number 1261 in the old bugs list.
- [2018/05/29]
-
Fixed minor bug in Date.toString (missing leading "0" for day of month). This issue was bug number 1444 in the old bugs list.
- [2018/05/29]
-
Cleaned up match compiler code (
FLINT/trans/matchcomp.sml
) and added typing and function comments. Added debugging and printing infrastructure, including newFLINT/trans/mcprint.sml
file, and newControl.MC.debugging
flag.
- [2018/05/29]
-
Fixed parser to allow parentheses around
val rec
patterns.
- [2018/05/28]
-
Fixed the scanner to produce the correct error message for bad escape sequences in string literals.
- [2018/05/26]
-
Fixed old bug number 1383:
Char.toCString #"\000"
returned"\\0"
, instead of"\\000"
, which causedString.toCString
to produce invalid results.
- [2018/05/19]
-
Fix for bug #201 (The AMD64.cm library is missing).
- [2018/05/18]
-
Added
MONO_BUFFER
signature, with instancesCharBuffer
andWord8Buffer
, to Basis implementation ( Basis Library Proposal 2018-001).
- [2018/05/16]
-
Fix a bug where “0w” was being accepted as a prefix for a hexidecimal word value in
Word.fromString
/scan
(ignoring case, only “0x” and “0wx” are valid prefixes). This change fixes bug number 1375 from the old bugs list.
- [2018/05/13]
-
Fixed a bug in the parsing of bindings involving the
op
keyword. The parser was more restrictive than the definition. This change fixes bug number 1370 from the old bugs list.
- [2018/05/12]
-
The lexer gave an unmatched close comment error on "*)", when it should have scanned it as the tokens "*" ")". This change fixes bug number 330 in the old bugs list.
Note: there is some ambiguity as to what the correct behavior should be here. The Definition of Standard ML (1997) only says that unmatched open comments should be signalled as errors, but the Commentary on the Definition of Standard ML (1991) says otherwise in Appendix D. SML/NJ started signalling an error in version 0.71, but we choose to revert to accepting this sequence, to match the 1997 Definition (and the behavior of other systems).
- [2018/05/07]
-
The
sameSign
function returned incorrect results in theInt31
andInt32
modules.
- [2018/05/07]
-
Fixed various minor parsing and scanning issues:
-
correct syntax for type variables
-
signature/structure/functor IDs should always be alpha IDs
-
the equality ID (
=
) cannot appear in a binding context. Note that we still allow the syntaxval op = = …
because it is needed to parse the filesystem/smlnj/init/built-in.sml
.
-
- [2018/05/05]
-
Completed overhaul of the way that int/word literals are handled in the compiler. We now use
IntInf.int
to represent the values in all IRs. This change also results in better CPS contraction, since we now perform constant folding for both signed and unsigned values at all sizes. We were also able to get rid of the tricky code that worries about large tagged integer values that might cause overflow during code generation.
- [2018/04/21]
-
Improved the reporting of errors involving literal values. We now use the original source text when describing the value in the error message.
- [2018/04/20]
-
Fix for bug #191 (Compiler crash when handling large reals). We now issue a warning for real literals that will round to zero and an error for real literals that are too large to represent. There still needs to be done some work to support sub-normal literal values (these are currently rounded to zero).
- [2018/04/14]
-
Changed the representation of real literals from strings to
RealLit.t
.
- [2018/04/13]
-
Removed real patterns from Absyn and FLINT, since they are not allowed by SML'93 and were not present in the AST representation.
- [2018/04/12]
-
Fix for bug #194 (
Real.fromString
overflows or hangs). There were two issues here. First, theOverflow
exception was being raised when scanning large exponents, but it was not being handled by the scanning code. The second issue was that the scaling loop for large exponents did not immediately terminate once infinity (or zero) was reached, so it could take a long time.
- [2017/10/22]
-
Moved the Version-1 literal building code into
gc/old-literals.c
. This file can be removed once the compiler generates the Version-2 literal bytecode.
- [2017/10/16]
-
Moved the check for whether a int or word literal is in range for its type from the absyn→plambda translation to the overload resolver (
compiler/Elaborator/types/overload.sml
).
- [2017/10/14]
-
Part 1 of an overhaul of the way that the compiler treats int/word literals. The end goal is to use
IntInf.int
to represent literals throughout all phases of the compiler. In this step, we changed the representation of literals in theAbsyn
representation (earlier representations already used IntInf.int).
Version 110.82; 2017/10/16
- [2017/10/01]
-
Fixed unnumbered bug in
IntInf.mod
andIntInf.rem
functions, where theDiv
exception was not getting raised when both arguments are0
.
- [2017/09/20]
-
Various bits of cleanup in the handling of primitive operations, such as removing the
ptnum
mechanism for translating from Absyn to FLINT.
- [2017/09/20]
-
Added
Target
module, which specifies the properties of the target (e.g., the size in bits of the default int type). Reworked the generation of theInlineT
structure to be target specific.
- [2017/09/18]
-
Removed FLINT primops (and their CPS counterparts) that are not in the
InlineT
structure and, thus, are never used by the compiler.
- [2017/09/18]
-
Fixed bug #123 (missing nonexhaustive bind warning). The
mkVBs
function inFLINT/trans/translate.sml
was adding a redundant default rule by callingElabUtil.completeMatch
after a default rule had already been explicitly added to the match for let bindings.
- [2017/09/18]
-
Fixed bug #183 (status code returned by sml REPL). This fix restores the version 110.79 behavior of having
sml foo.sml
exit with a non-zero status when there is a type-checking error infoo.sml
. It also cleans up the error messages associated withuse
when there is a syntax error.
- [2017/08/28]
-
Fixed bug #185 (Bring command line help text into parity with man page). Added missing options (
@SMLversion
and@SMLsuffix
) to the help message that is printed for the command “sml -h”. Also adjusted the order of options in the help message, and in the man page, so that the orders match.
- [2017/08/12]
-
Changed the way that we test for allocation-space addresses in minor GCs. Instead of using the BIBOP, we now do a pointer range test. On 32-bit systems, this change results in a small (~0.13%) performance boost, but we expect a bigger impact on 64-bit hardware, where the cost of BIBOP probes will be higher and there are more registers available to hold the nursery bounds.
- [2017/08/12]
-
Fixed some issues in build-literals.c. These were mostly false positives in the assertions, but there was also a bug in the way that the available space was tracked that could conceivably result in a crash (but was very unlikely).
- [2017/06/07]
-
Updated _arch-n-os script to recognize macOS 10.13 (High Sierra) as a valid target.
- [2017/05/17]
-
Fixed a bug in the way that JSON string values were being printed. The code previously assumed that C-style escaping will work, but that is not true for "\'" (as well as for control and non-ASCII characters). The new implementation assumes that the string value is UTF-8 and uses the "\\u" escape sequences for characters outside the JSON escapes and printable ASCII characters.
Version 110.81; 2017/05/01
- [2017/04/28]
-
Fixed bug #129 (Symbolic identifiers are allowed as strids).
- [2017/04/07]
-
Fixed bug #179 (ml-ulex writing debug messages to stdOut). Both ml-ulex and ml-antlr now direct their debug and status messages to
stdErr
(instead ofstdOut
).
- [2017/02/09]
-
Linux distributions are starting to require that the stack be marked as non-executable in applications. Because the runtime system includes assembly code, this marking was not happening. We’ve added
.section
directives to thePPC.prim.asm
andX86.prim.asm
files as per https://wiki.gentoo.org/wiki/Hardened/GNU_stack_quickstart#Patching. Thanks to Daniel Moerner for reporting this issue and for providing a pointer to the fix.
- [2016/10/15]
-
Added
--debug
command-line option to ml-antlr. This flag causes <b>ml-antlr</b> to generate debug actions that print the left-hand-side non-terminal of the production.
- [2016/09/15]
-
Working on 64-bit support. Changes include making code generation dependent on the target word size and abstracting over the BIBOP representation in the runtime system.
- [2016/09/15]
-
Further cleanup of the separation of FLINT from the front-end. Eliminated all references to
ModulePropLists
(module-plists.sml
) in the front end and in pickling, and movedmodule-plists
fromSemant/modules
toFLINT/trans
.ModulePropLists
is now only used inFLINT/trans/translate.sml
.Revision: 4314
Files changed:
-
compiler/ElabData/modules/modules.sml
(cleaned up) -
compiler/Elaborator/print/ppmod.sml
(cleaned up) -
compiler/FLINT/trans/module-plists.sml
(moved fromSemant/modules
) -
compiler/Semant/modules/instantiate-param.sml
(deleted) -
compiler/Semant/pickle/pickmod.sml
(no longer mentions property lists) -
compiler/Semant/pickle/unpickmod.sml
(ditto) -
compiler/Semant/statenv/prim.sml
-
compiler/Semant/types/tp-var-info.sml
(deleted) -
compiler/core.cm
(modified for move ofmodule-plists.sml
)
-
- [2016/09/14]
-
Eliminated dependency of
PlambdaType
from the front end by adding a typeTKind.tkind
which is a simplified standin forPlambdaType.tkind
for use during elaboration.TKind.tkind
values are translated on demand toPlambdaType.tkind
intrans/transtypes.sml
. Types still has atycpath
type but it is defined usingTKind.tkind
now. The new structureSigPropList
replacesModulePropLists
(Semant/modules/module-plists.sml
) for use ininstantiate.sml
.Instantiate
is now defined directly as a structure so the functor application inSemant/modules/instantiate.sml
no longer exists.Files changed:
-
ElabData/basics/debindex.sig
(moved here fromElaborator/basics
) -
ElabData/basics/debindex.sml
(ditto) -
ElabData/basics/sig-plist.sml
(new) -
ElabData/basics/tkind.sml
(new) -
ElabData/types/types.sig
-
ElabData/types/types.sml
-
Elaborator/modules/instantiate.sml
-
Elaborator/print/ppmod.sml
-
FLINT/trans/transtkind.sml
(new) -
FLINT/trans/transtypes.sml
-
TopLevel/interact/evalloop.sml
-
ElabData/elabdata.cm
-
Elaborator/elaborate.cm
-
core.cm
-
- [2016/09/14]
-
Added support for Successor ML record-expression-punning syntax. For example, one can now define a function
f
asfun f x = {x}
which is equivalent to the definition
fun f x = {x = x}
- [2016/09/14]
-
Fixed a bug in the parser. Asterix (
*
) was not allowed as a record label when using the record-pattern-punning syntax.
- [2016/09/14]
-
Added support for
do exp
Successor ML syntax.
- [2016/09/12]
-
Fixed bug #153 (Enabling Successor ML features is delayed). We now use a function
Control.setSuccML
to switch to/from Successor ML mode in the REPL. The function resets the parser, so the next input will be correctly parsed. TheControl.succML
flag is no longer visibile in the REPL.
- [2016/09/12]
-
Fixed bug #149 (Datatype replication exposes hidden constructors). Added boolean field
stripped
to DATATYPE variant of tyckind incompiler/ElabData/types/types.sml
with default valuefalse
.stripped
is set to true when a datatype is matched with a simpletype
spec in signature matching, and datatypes withstripped
set to true are disallowed in datatype replications.Files changed:
-
compiler/ElabData/types/types.sig
-
compiler/ElabData/types/types.sml
-
compiler/ElabData/types/typesutil.sml
-
compiler/ElabData/types/core-basictypes.sml
-
compiler/Elaborator/types/basictypes.sml
-
compiler/Elaborator/types/eqtypes.sml
-
compiler/Elaborator/modules/evalent.sml
-
compiler/Elaborator/modules/sigmatch.sml
-
compiler/Elaborator/modules/instantiate.sml
-
compiler/Elaborator/print/ppabsyn.sml
-
compiler/Elaborator/print/pptype.sml
-
compiler/Elaborator/elaborate/elabcore.sml
-
compiler/Elaborator/elaborate/elabmod.sml
-
compiler/Elaborator/elaborate/elabtype.sml
-
compiler/Elaborator/elaborate/elabsig.sml
-
compiler/Semant/pickle/pickmod.sml
-
compiler/Semant/pickle/unpickmod.sml
-
compiler/MiscUtil/print/ppobj.sml
-
compiler/FLINT/trans/transtypes.sml
-
compiler/FLINT/trans/pequal.sml
-
- [2016/08/31]
-
Added
%tokentype
directive to ml-antlr; this directive allows users to specify the token datatype externally, which is necessary in order to share a lexer with two different ml-antlr parsers.
- [2016/08/20]
-
Change the interface to
AMD64Gen
in MLRISC; thesignBit
andnegateSignBit
callbacks now return anMLTree.rexp
(instead of a label).
Version 110.80; 2016/08/19
- [2016/08/16]
-
Fixed #151 (Error installing from source on Mac OS X). The fix involves both changes to the
config/install.sh
script and themk.x86-darwin
makefile. With this fix, we include theSDK
argument to the/usr/bin/as
only when the OS version is 10.10 (Yosemite) or later.
- [2016/08/10]
-
Added the proposed
unzipMap
,unzipMapi
,find
, andfindi
functions to theListPair
module.
- [2016/08/10]
-
Added the proposed
mapLeft
,mapRight
,appLeft
, andappRight
functions to theEither
module.
- [2016/08/09]
-
Fixed bug #145 (Internal exception occurs on bogus annotation instead of typechecking diagnostic). Added missing
OVLD_UB
case in functionfailMessage
incompiler/Elaborator/types/unify.sml
.
- [2016/08/04]
-
Fixed bug #166 (Can’t install SML/NJ in directories containing spaces). Thanks to Eugene Sharygin for the patch.
- [2016/06/21]
-
Fixed incorrect dividend sign extension before 32-bit divide in amd64 code generator in MLRISC
- [2016/06/16]
-
Fixed bug #150 (Add title to batch script).
- [2016/05/11]
-
Implemented the changes for Basis Library Proposal 2016-001. This proposal added the
popCount
function to theWORD
signature.
- [2016/05/03]
-
Fixed bug #156 (sml resumes after SIGSTOP with bogus exception report). The fix is a bit of a hack: I modified the
non_bt_hdl
function inevalloop.sml
to match anIO.Io
exception with the appropriate shape for this situation.
- [2016/04/07]
-
Fixed bug #154 (Return code for ml-ulex when there is an error).
- [2016/04/07]
-
Fixed bug #155 (Misleading printing of word literals in error messages).
- [2016/04/02]
-
Fixed a bug in the implementation of the
--ml-lex-mode
flag for ml-ulex. The\h
escape sequence is supposed to map to the character range[\128-\255]
, but did not.
- [2015/11/09]
-
Fixed bug #147 (Hexadecimal escapes in strings are not supported). We previously did not support Unicode escapes in string literals. We now do so, with non-ascii codepoints being mapped to the UTF-8 encoding with escape values in the range 0..255 being mapped to the corresponding 8-bit character. Values outside that range are flagged as an error.
Revised August 4, 2016
- [2015/10/28]
-
Partial fix for the noisy exception-stack traces on the
Error
exception. The cases that are handled by this change are applyinguse
to a non-existent file and when there are compilation errors in a program being built byCM.make
. What remains to be handled is the situation whereCM.make
is applied to a non-existent file.
Version 110.79; 2015/10/04
- [2015/10/04]
-
Patched
base/compiler/FLINT/clos/closure.sml
so that Twelf will build again. Fixes bug #140 (Lookup failure inclosure.sml
when compiling Twelf).
- [2015/09/28]
-
Added support for a Successor ML tool to CM. This tool allows one to specify that a source file
fool.sml
is Successor ML source code in the following ways:foo.sml : succ-ml foo.sml : sml (succ-ml) foo.sml (succ-ml)
- [2015/09/28]
-
Added the directory
base/old-basis
to support backward-compatible views of the Basis Library. You can use these by replacing the line$/basis.cm
with
$/basis-2004.cm
in your CM files.
- [2015/09/28]
-
New implementation of
Date
structure in the Basis, which fixes bugs #138 (Incorrect behavior forDate.fromTimeLocal
) and #139 (Date.date
is broken). Note that some more thought should be given to the correct semantics ofDate.date
when dealing with offsets. For example, should an offset of +23 hours produce the same date as an offset of -1 hours? Currently our implementation produces different results (by a day) for these two situations.
- [2015/09/25]
-
Implemented the changes for Basis Library Proposal 2015-003. This proposal added operations to the following signatures:
signature ARRAY signature LIST signature LIST_PAIR signature MONO_ARRAY signature MONO_VECTOR signature OPTION signature STRING signature TEXT signature VECTOR
and the following structures:
structure Array : ARRAY structure CharArray : MONO_ARRAY structure CharVector : MONO_VECTOR structure List : LIST structure ListPair : LIST_PAIR structure Option : OPTION structure Real64Array : MONO_ARRAY structure Real64Vector : MONO_VECTOR structure String : STRING structure Text : TEXT structure Vector : VECTOR structure Word8Array : MONO_ARRAY structure Word8Vector : MONO_VECTOR
While it is very unlikely that these changes will break existing code, there are a a couple scenarios in which the code might break. Namely, when use of
open
introduces conflicts and when user code implements one of the affected Basis Library signatures. Both of these examples occurred in the SML/NJ source code; the former in the ml-yacc sources and the latter in the MLRISC sources.
- [2015/09/25]
-
Added the optional implementations of
PackReal64Big
andPackReal64Little
. This addition addresses feature request #82 (Implementations ofPACK_REAL
missing). The implementation uses the approach suggested by Michael Sullivan.
- [2015/09/24]
-
Fixed bug #45 (Compiler bug in specialize phase). This bug was in
compiler/FLINT/opt/fcontract.sml
and was the result of a bad interaction between eta contraction and inlining. As part of the fix, I cleaned up the code in this part of FLINT a bit.
- [2015/09/21]
-
Improvements to the error messages produced by the ml-ulex lexer generator.
- [2015/09/21]
-
Added
Ref
structure andREF
signature to Basis implementation ( Basis Library Proposal 2015-007).
- [2015/09/21]
-
Added
Fn
structure andFN
signature to Basis implementation ( Basis Library Proposal 2015-005).
- [2015/08/22]
-
Fixed bug #136 (Incorrect raising of exceptions in
Real.fmt
andTime.fmt
).
- [2015/08/14]
-
Added
Either
structure andEITHER
signature to Basis implementation ( Basis Library Proposal 2015-002).
- [2015/07/23]
-
Fixed bug #135 (Fails to build on Linux PowerPC).
- [2015/07/08]
-
Added Linux 4.* kernels to the list of operating systems recognized by the
.arch-n-opsys
script (fixes bug #134).
- [2015/06/11]
-
Added Mac OS X 10.11 (El Capitan) to the list of operating systems recognized by the
.arch-n-opsys
script.
- [2015/05/27]
-
Added support for Successor ML lexical extensions. These can be enabled using the command-line option
-Cparser.succ-ml=true
or by the assignmentControl.succML := true;
at the REPL. The extensions are as follows:
-
Underscore (“_”) as a separator in numeric literals; e.g.,
123_456
,0wxff_ff_ff_f3
,123_456.1
, … -
end-of-line comments, which are denoted using
(*)
. End-of-line comments properly nest into conventional block comments. For example, the following block comment is well formed:(* fun f x = x (*) my identity function *) *)
-
binary literals for both integers and words; e.g.,
0b0101_1110
, or0wb1101
.
This change is the beginning of a program to add Successor ML feature to SML/NJ; See https://github.com/SMLFamily/Proposed-Definition-of-Successor-ML for more details.
-


WITNESS LIST Environmental Regulation Committee (Subcommittee on Local Emergency Planning Committees (LEP) May 29, 1998-9:30A LEPC Funding For: Baker, Steve (Tarrant County LEPC) Davis, Brett J. (Travis County LEPC) Kelley, Walt (Potter/Randall LEPC) Mixon, Carl L. (Bexar County LEPC) On: Allen, R.J. (Bob) (Crp.Christi/Nueces LEPC) McKinney, Paula (herself/TDH) Moore, Dale "Phillip" (himself/DPS)


flibs/m_vstringformat(n) 1.0 "flibs"
flibs/m_vstringformat - Formatting dynamic strings
TABLE OF CONTENTS
SYNOPSIS
DESCRIPTION
OVERVIEW
Formatting logical values
Formatting integer values
Limitations
Planned features
METHODS
COPYRIGHT
The module m_vstringformat provides services to format one string, that is to
say to convert a basic fortran data type into a dynamic vstring.
The current version of m_vstringformat can handle logical variables
and integers of all kinds. The format can be given by the client code,
or computed automatically. The format can be given as a basic character
string, or as a vstring.
The only method provided here is vstring_format, which takes one basic
basic fortran data type as the first argument (and, optionnaly, a format),
and returns a dynamic string which represents that value.
One can format a logical into a vstring with automatic or explicit format.
In the following sample, one format the ".false." logical into a vstring.
After formatting, the string "mystring" has a length of 1 and its content
is "F".
| |
logical :: mybool
type ( t_vstring ) :: mystring
mybool = .false.
mystring = vstring_format ( mybool )
|
In the following sample, one format the ".false." logical into a vstring
with an explicit format given as a character string :
| |
logical :: mybool
type ( t_vstring ) :: mystring
mybool = .false.
mystring = vstring_format ( mybool , "(L3)" )
|
After formatting, the string "mystring" has a length of 3 and its content
is " F".
In the following sample, one format the ".false." logical into a vstring
with an explicit format given as a vstring :
| |
logical :: mybool
type ( t_vstring ) :: mystring
type ( t_vstring ) :: myformat
mybool = .false.
call vstring_new ( myformat , "(L3)" )
mystring = vstring_format ( mybool , myformat )
call vstring_free ( myformat )
|
One can format an integer into a vstring, with automatic or explict format.
The string formatting system can handle all fortran kinds of integers.
The automatic format makes so that the resulting string has the
length which exactly matches the number of digits necessary to represent
the integer :
- if the integer is negative, the "-" sign is at the begining of the string,
- if the integer is positive, the "+" sign is not in the string.
In the following example, one formats the integer 2008 into a vstring.
After formatting, the string has a length of 4 and its content is the
string "2008".
| |
type ( t_vstring ) :: mystring
mystring = vstring_format ( 2008 )
|
To acheive the same effect, one can use the "I0" format of the fortran 90
standard :
| |
type ( t_vstring ) :: mystring
mystring = vstring_format ( 2008 , "(I0)" )
|
The component can handle long integers with specified kinds 1, 2, 4 or 8.
In the following example, one automatically format a 32-bits integer
(1073741824 = 2**31) into a dynamic string.
| |
integer (kind=4) :: integerkind4 =<PHONE_NUMBER>
mystring = vstring_format ( integerkind4 )
|
After formatting, the string has a length of 4 and its content is the
string "1073741824".
The current implementation of the string formatting is based
on the standard "write" fortran statement, which takes
a basic character string as argument.
Moreover the format given to the string formatting command
is not analysed at all, so that the length of the resulting
string is not computed.
The current component use therefore a character string of
fixed length VSTRING_FORMAT_MAXIMUM_FORMAT_LENGTH.
This leads to at least two limitations :
- if the client code has to manage formated strings which length is over
VSTRING_FORMAT_MAXIMUM_FORMAT_LENGTH characters, the
current algorithm will generate an error at execution time.
- the "write" statement has to manage a long string, even
if the result is short, which raise performances issues.
The current string formatting takes only one value.
An effective implementation would in fact take a list of
one or more arguments, which may be of different types.
The current implementation does not manage real values.
The limitations of the current component are so strong that the
component should not be released... but is useful to format
integers and that is why it has been finally released.
It is expected that future releases of this component can manage
more basic data types, including real types of all kinds.
Future releases may also extend the formats by taking into account
string formatting coming from other languages than fortran (for example C),
including:
- the "-" specification which specifies that the converted argument
should be left-justified in its field
- the "+" specification which specifies that a number should always
be printed with a sign, even if positive.
- etc...
- vstring_format value ?fmt?
-
- <value type>, intent(in) :: value
-
- <fmt type>, intent(in), optional :: fmt
-
Generic converter from a basic fortran data type into a vstring.
Returns a new dynamic string with type t_vstring by formating the
given value against the optional format fmt.
The value may be a logical or and integer of kind 1, 2, 4 or 8 to format.
If fmt is provided, then this format is used to compute the
new string. If format is provided, it may be either with a character(len=*) type
or with a t_vstring type.
If format is not provided, an automatic format is computed and applied
to compute the new string. With automatic format, the computed
string has a minimum length, that is, does not contain any blank and
begins with "-" only if the value is a strictly negative integer.
- vstring_format logical_value
-
- logical , intent(in) :: logical_value
-
Returns a new vstring by formatting the logical logical_value
with automatic format.
- vstring_format logical_value fmt
-
- logical , intent(in) :: logical_value
-
- character(len=*), intent(in) :: fmt
-
Returns a new vstring by formatting the logical logical_value
with the given character(len=*) format fmt.
- vstring_format logical_value fmt
-
- logical, intent(in) :: logical_value
-
- type ( t_vstring ), intent(in) :: fmt
-
Returns a new vstring by formatting the logical logical_value
with the given vstring format fmt.
- vstring_format integer_value
-
- integer (kind = INTEGER_KIND ), intent(in) :: integer_value
-
Returns a new vstring by formatting the integer integer_value with an automatic format.
With automatic format, the computed
string has a minimum length, that is, does not contain any blank and
begins with "-" only if the integer_value is a strictly negative integer.
The INTEGER_KIND kind of integer may by 1, 2, 4 or 8.
- vstring_format integer_value fmt
-
- integer (kind = INTEGER_KIND ), intent(in) :: integer_value
-
- character(len=*), intent(in) :: fmt
-
Returns a new vstring by formatting the integer integer_value
with the given format fmt.
The INTEGER_KIND kind of integer may by 1, 2, 4 or 8.
- vstring_format integer_value fmt
-
- integer (kind = INTEGER_KIND ), intent(in) :: integer_value
-
- type ( t_vstring ), intent(in) :: fmt
-
Returns a new vstring by formatting the integer integer_value
with the given format fmt.
The INTEGER_KIND kind of integer may by 1, 2, 4 or 8.
Copyright © 2008 Michael Baudin michael.baudin@gmail.com


{% extends "mails/messages/activity_base.html" %} {% load i18n %} {% block message %}
{% blocktrans context 'email' %} The activity "{{ title }}" has changed: {% endblocktrans %}
{% if duration %} {% include 'mails/messages/partial/period.html' %} {% else %} {% include 'mails/messages/partial/slots.html' %} {% endif %}
{% blocktrans context 'email' %} Read the latest updates on the activity page. {% endblocktrans %}
{% endblock %} {% block end_message %}
{% blocktrans context 'email' %} If you are unable to participate, please withdraw via the activity page so that others can take your place. {% endblocktrans %}
{% endblock %}


Dem Rep. Khanna on Bloomberg Presidential Run: 'You Think The Country Really Wants Another New York Billionaire After Trump?' | Breitbart
by Trent BakerFriday on CNN’s “New Day,” Rep. Ro Khanna (D-CA) weighed in on former New York City Mayor Michael Bloomberg potentially entering the 2020 presidential race.
Khanna pushed back against the idea, saying he does not see the United States wanting to elect “another New York billionaire after Donald Trump.”
“Well, John, do you think the country really wants another New York billionaire after Donald Trump?” Khanna asked host John Berman. “Usually, we elect the opposite. And so I just don’t think this is the time where his vision or his ideas are going to resonate.”
The congressman from California admitted Bloomberg has done good work in fighting climate change and gun violence, but voiced his concern with the former mayor’s comments on the #MeToo movement and stop and frisk.
“I don’t think he has progressive economic ideas,” Khanna added. “And frankly, I just don’t think this country needs another billionaire running for political office.”
Follow Trent Baker on Twitter @MagnifiTrent


| 1 | /* | |
| 2 | * Licensed to the Apache Software Foundation (ASF) under one or more | |
| 3 | * contributor license agreements. See the NOTICE file distributed with | |
| 4 | * this work for additional information regarding copyright ownership. | |
| 5 | * The ASF licenses this file to You under the Apache License, Version 2.0 | |
| 6 | * (the "License"); you may not use this file except in compliance with | |
| 7 | * the License. You may obtain a copy of the License at | |
| 8 | * | |
| 9 | * http://www.apache.org/licenses/LICENSE-2.0 | |
| 10 | * | |
| 11 | * Unless required by applicable law or agreed to in writing, software | |
| 12 | * distributed under the License is distributed on an "AS IS" BASIS, | |
| 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| 14 | * See the License for the specific language governing permissions and | |
| 15 | * limitations under the License. | |
| 16 | */ | |
| 17 | ||
| 18 | package org.apache.commons.math3.optimization.direct; | |
| 19 | ||
| 20 | import org.apache.commons.math3.analysis.MultivariateFunction; | |
| 21 | import org.apache.commons.math3.optimization.BaseMultivariateOptimizer; | |
| 22 | import org.apache.commons.math3.optimization.BaseMultivariateSimpleBoundsOptimizer; | |
| 23 | import org.apache.commons.math3.optimization.GoalType; | |
| 24 | import org.apache.commons.math3.optimization.InitialGuess; | |
| 25 | import org.apache.commons.math3.optimization.SimpleBounds; | |
| 26 | import org.apache.commons.math3.optimization.PointValuePair; | |
| 27 | import org.apache.commons.math3.optimization.ConvergenceChecker; | |
| 28 | ||
| 29 | /** | |
| 30 | * Base class for implementing optimizers for multivariate scalar functions, | |
| 31 | * subject to simple bounds: The valid range of the parameters is an interval. | |
| 32 | * The interval can possibly be infinite (in one or both directions). | |
| 33 | * This base class handles the boiler-plate methods associated to thresholds | |
| 34 | * settings, iterations and evaluations counting. | |
| 35 | * | |
| 36 | * @param <FUNC> Type of the objective function to be optimized. | |
| 37 | * | |
| 38 | * @version $Id$ | |
| 39 | * @deprecated As of 3.1 (to be removed in 4.0). | |
| 40 | * @since 3.0 | |
| 41 | * @deprecated As of 3.1 since the {@link BaseAbstractMultivariateOptimizer | |
| 42 | * base class} contains similar functionality. | |
| 43 | */ | |
| 44 | @Deprecated | |
| 45 | public abstract class BaseAbstractMultivariateSimpleBoundsOptimizer<FUNC extends MultivariateFunction> | |
| 46 | extends BaseAbstractMultivariateOptimizer<FUNC> | |
| 47 | implements BaseMultivariateOptimizer<FUNC>, | |
| 48 | BaseMultivariateSimpleBoundsOptimizer<FUNC> { | |
| 49 | /** | |
| 50 | * Simple constructor with default settings. | |
| 51 | * The convergence checker is set to a | |
| 52 | * {@link org.apache.commons.math3.optimization.SimpleValueChecker}. | |
| 53 | * | |
| 54 | * @see BaseAbstractMultivariateOptimizer#BaseAbstractMultivariateOptimizer() | |
| 55 | * @deprecated See {@link org.apache.commons.math3.optimization.SimpleValueChecker#SimpleValueChecker()} | |
| 56 | */ | |
| 57 | @Deprecated | |
| 58 | protected BaseAbstractMultivariateSimpleBoundsOptimizer() {} | |
| 59 | ||
| 60 | /** | |
| 61 | * @param checker Convergence checker. | |
| 62 | */ | |
| 63 | protected BaseAbstractMultivariateSimpleBoundsOptimizer(ConvergenceChecker<PointValuePair> checker) { | |
| 64 | super(checker); | |
| 65 | } | |
| 66 | ||
| 67 | /** {@inheritDoc} */ | |
| 68 | @Override | |
| 69 | public PointValuePair optimize(int maxEval, FUNC f, GoalType goalType, | |
| 70 | double[] startPoint) { | |
| 71 |
1
1. optimize : mutated return of Object value for org/apache/commons/math3/optimization/direct/BaseAbstractMultivariateSimpleBoundsOptimizer::optimize to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return super.optimizeInternal(maxEval, f, goalType, |
| 72 | new InitialGuess(startPoint)); | |
| 73 | } | |
| 74 | ||
| 75 | /** {@inheritDoc} */ | |
| 76 | public PointValuePair optimize(int maxEval, FUNC f, GoalType goalType, | |
| 77 | double[] startPoint, | |
| 78 | double[] lower, double[] upper) { | |
| 79 |
1
1. optimize : mutated return of Object value for org/apache/commons/math3/optimization/direct/BaseAbstractMultivariateSimpleBoundsOptimizer::optimize to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return super.optimizeInternal(maxEval, f, goalType, |
| 80 | new InitialGuess(startPoint), | |
| 81 | new SimpleBounds(lower, upper)); | |
| 82 | } | |
| 83 | } | |
Mutations | ||
| 71 |
1.1 |
|
| 79 |
1.1 |


[gecode-users] Problem compiling Gecode 2.0.0 in PowerPC
Mauricio Toro
mauriciotorob at gmail.com
Fri Feb 15 10:18:09 CET 2008
Hello,
I am trying to compile Gecode 2.0.0 and I also
tried with Gecode 2.0.1 in a PowerPC G5 Machine
running Mac OS X 10.4.8 and GCC 4.0.0.
I got this errors:
make
make[1]: `gecode/int/var/imp-int-hdr.icc' is up to date.
make[1]: `gecode/int/var/imp-int-body.icc' is up to date.
make[1]: `gecode/int/var/imp-bool-hdr.icc' is up to date.
make[1]: `gecode/int/var/imp-bool-body.icc' is up to date.
make[1]: `gecode/set/var/imp-hdr.icc' is up to date.
make[1]: `gecode/set/var/imp-body.icc' is up to date.
make[1]: `gecode/cpltset/var/imp-hdr.icc' is up to date.
make[1]: `gecode/cpltset/var/imp-body.icc' is up to date.
make[1]: `libgecodesupport.9.0.dylib' is up to date.
make[1]: `libgecodekernel.9.0.dylib' is up to date.
make[1]: `libgecodesearch.9.0.dylib' is up to date.
g++ -I. -DNDEBUG -fvisibility=hidden -fPIC -Wextra -Wall -pipe -ggdb -O3
-fno-strict-aliasing -finline-limit=3000 -ffast-math \
-c -o gecode/int/distinct.o gecode/int/distinct.cc
./gecode/int/distinct/dom.icc: In member function `bool
Gecode::Int::Distinct::DomCtrl<View>::ViewValGraph::match(Gecode::Support::SentinelStack<Gecode::Int::Distinct::ViewNode<View>*>&,
Gecode::Int::Distinct::ViewNode<View>*)':
./gecode/int/distinct/dom.icc:258: error:
'Gecode::Int::Distinct::DomCtrl<View>::ViewValGraph::count' cannot appear in
a constant-expression
./gecode/int/distinct/dom.icc:258: error: missing '>' to terminate the
template argument list
./gecode/int/distinct/dom.icc: In member function `void
Gecode::Int::Distinct::DomCtrl<View>::ViewValGraph::mark()':
./gecode/int/distinct/dom.icc:406: error:
'Gecode::Int::Distinct::DomCtrl<View>::ViewValGraph::count' cannot appear in
a constant-expression
./gecode/int/distinct/dom.icc:406: error: missing '>' to terminate the
template argument list
./gecode/int/distinct/dom.icc:411: error:
'Gecode::Int::Distinct::DomCtrl<View>::ViewValGraph::count' cannot appear in
a constant-expression
./gecode/int/distinct/dom.icc:411: error: missing '>' to terminate the
template argument list
./gecode/int/distinct/dom.icc:429: error:
'Gecode::Int::Distinct::DomCtrl<View>::ViewValGraph::count' cannot appear in
a constant-expression
./gecode/int/distinct/dom.icc:429: error: missing '>' to terminate the
template argument list
./gecode/int/distinct/dom.icc:436: error:
'Gecode::Int::Distinct::DomCtrl<View>::ViewValGraph::count' cannot appear in
a constant-expression
./gecode/int/distinct/dom.icc:436: error: missing '>' to terminate the
template argument list
./gecode/int/distinct/dom.icc:446: error: '->' cannot appear in a
constant-expression
./gecode/int/distinct/dom.icc:446: error: missing '>' to terminate the
template argument list
make[1]: *** [gecode/int/distinct.o] Error 1
make: *** [compilelib] Error 2
Any clues?
Thank you
--
Mauricio Toro Bermudez
Estudiante de Ingeniería de Sistemas
Pontificia Universidad Javeriana, Colombia
Stagiare à l'Ircam
1, place Igor-Stravinsky 75004 Paris,
France de 2008 à 2009
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <http://www.ps.uni-sb.de/pipermail/users/attachments/20080215/0463627c/attachment.htm>
More information about the gecode-users
mailing list


Chuppy allows you to easily share and organize your files and data without messing with DNS and firewall settings.
Chuppy enables you to collaborate with your team members and provides flexible communication platform.
Download Chuppy and start it!
https://github.com/LogIN-/chuppy
Windows
Linux
MacOS
Open Source MIT License
When you start and stop Chuppy, you will see it reflected in the active count below.
See the github page for info on API.


Educational Management Information System
| © Educational Management Information System
|
| Project Designed & Developed by AU-KBC Research Centre, Anna University Chennai |
| Project Designed & Developed by AU-KBC Research Centre, Anna University Chennai |