Literal handling improvements (#1202)

* WIP: 64 literal diagnostic and truncation.

* Improve how integer truncation is handled/supported.
Added literal-int64.slang test.
Set a suffix on all literals.
Fixed problem on C++ based targets where l suffix was not the same as int() cast. So on C++ derived emitters, int() is used instead of l suffix to have same behavior across targets.

* Add literal diagnostic testing.

* Allow lexer to lex - in front of literals.

* Fix lexing and converting int literal with -.

* Too large small values of floats become inf.
Handling writing inf types out on different targets.
Add function to deterimine if a float literals kind.

* Roll back the support of lexer lexing negative literals.

* Fixed tests broken because of diagnostics numbers.
Improved _isFinite

* Fix compilation on linux.

* Fix problem with abs on linux - use Math::Abs.

* Fix typo.

* * Improve warnings for float literals zeroed
* Improved 64 bit type documentation
* Handle half
* Improved comments
* Fixed tests broken
* Use capital letters for suffixes.

* Make default behavior on outputting a int literal that is an 'int32_t' is cast (not suffix) to avoid platform inconsistencies.
Improve documentation for 64 bit types.
Make tests cover material in docs.

* Fixed tests.

* Rename FloatKind::Normal -> Finite

* Fix half zero check.

1 files changed, 36 insertions, 12 deletions

diff --git a/source/slang/slang-emit-cpp.cpp b/source/slang/slang-emit-cpp.cpp
index 30388479e..ae1798382 100644
--- a/source/slang/slang-emit-cpp.cpp
+++ b/source/slang/slang-emit-cpp.cpp
@@ -1883,23 +1883,47 @@ void CPPSourceEmitter::emitSimpleFuncImpl(IRFunc* func)
 
 void CPPSourceEmitter::emitSimpleValueImpl(IRInst* inst)
 {
-    switch (inst->op)
+    if (inst->op == kIROp_FloatLit)
     {
-        case kIROp_FloatLit:
+        IRConstant* constantInst = static_cast<IRConstant*>(inst);
+        switch (constantInst->getFloatKind())
         {
-            IRConstant* constantInst = static_cast<IRConstant*>(inst);
-
-            m_writer->emit(constantInst->value.floatVal);
-
-            // If the literal is a float, then we need to add 'f' at end
-            IRType* type = constantInst->getDataType();
-            if (type && type->op == kIROp_FloatType )
+            case IRConstant::FloatKind::Nan:
             {
-                m_writer->emitChar('f');
+                // TODO(JS): 
+                // It's not clear this will work on all targets.
+                // In particular Visual Studio reports an error with this expression. 
+                m_writer->emit("(0.0 / 0.0)");
+                break;
+            }
+            case IRConstant::FloatKind::PositiveInfinity:
+            {
+                m_writer->emit("SLANG_INFINITY");
+                break;
+            }
+            case IRConstant::FloatKind::NegativeInfinity:
+            {
+                m_writer->emit("(-SLANG_INFINITY)");
+                break;
+            }
+            default:
+            {
+                m_writer->emit(constantInst->value.floatVal);
+
+                // If the literal is a float, then we need to add 'f' at end, as
+                // without literal suffix the value defaults to double.
+                IRType* type = constantInst->getDataType();
+                if (type && type->op == kIROp_FloatType)
+                {
+                    m_writer->emitChar('f');
+                }
+                break;
             }
-            break;
         }
-        default: Super::emitSimpleValueImpl(inst);
+    }
+    else
+    {
+        Super::emitSimpleValueImpl(inst);
     }
 }