eC - Programming language

eC, aka Ecere C, is an open source programming language created in 2004 by Jérôme Jacovella-St-Louis.

Source code:

git clone https://github.com/ecere/ecere-sdk/

#291on PLDB

20Years Old

139Repos

Try now: Riju · TIO

eC (Ecere C) is an object-oriented programming language, defined as a super-set of the C language. eC was initially developed as part of the Ecere Cross-platform Software Development Kit project. The goals of the language are to provide object-oriented constructs, reflection, properties and dynamic modules on top of the C language while maintaining C compatibility and optimal native performance.eC currently relies on GCC or Clang to perform the final steps of compilation, using C as an intermediate language. Read more on Wikipedia...

eC website
eC Wikipedia page
eC is developed on GitHub and has 298 stars
There are at least 139 eC repos on GitHub
eC first developed in Ecere Corporation
file extensions for eC include ec and eh
The Google BigQuery Public Dataset GitHub snapshot shows 894 users using eC in 920 repos on GitHub
Explore eC snippets on Rosetta Code
Pygments supports syntax highlighting for eC
GitHub supports syntax highlighting for eC
ec-lang.org was registered in 2014
See also: (8 related languages)C, Python, LLVM IR, Linux, FreeBSD, Android, JavaScript, WebAssembly

Example from Riju:

class Main : Application
{
   void Main()
   {
      PrintLn("Hello, world!");
   }
}

Example from hello-world:

class HelloWorldApp : Application
{
   void Main()
   {
      PrintLn("Hello World");
   }
}

Example from Linguist:

import "ide"

class Designer : DesignerBase
{
   ~Designer()
   {
      if(GetActiveDesigner() == this)
      {
         SetActiveDesigner(null);
      }
      if(classDesigner)
         delete classDesigner;
   }

   // *** DesignerBase Implementation ***

   void ModifyCode()
   {
      codeEditor.ModifyCode();
   }

   void UpdateProperties()
   {
      codeEditor.DesignerModifiedObject();
   }

   void CodeAddObject(Instance instance, ObjectInfo * object)
   {
      codeEditor.AddObject(instance, object);
   }

   void SheetAddObject(ObjectInfo object)
   {
      codeEditor.sheet.AddObject(object, object.name, typeData, true); //className, true);
   }

   void AddToolBoxClass(Class _class)
   {
      ((IDEWorkSpace)master).toolBox.AddControl(_class);
   }

   void AddDefaultMethod(Instance instance, Instance classInstance)
   {
      Class _class = instance._class;
      Method defaultMethod = null;

      for( ; _class; _class = _class.base)
      {
         Method method;
         int minID = MAXINT;
         for(method = (Method)_class.methods.first; method; method = (Method)((BTNode)method).next)
         {
            if(method.type == virtualMethod)
            {
               if(!method.dataType)
                  method.dataType = ProcessTypeString(method.dataTypeString, false);
               if(method.vid < minID && (instance == classInstance || (method.dataType.thisClass && eClass_IsDerived(classInstance._class, method.dataType.thisClass.registered))))
               {
                  defaultMethod = method;
                  minID = method.vid;
               }
            }
         }
         if(defaultMethod)
            break;
      }
      codeEditor.AddMethod(defaultMethod);
   }

   bool ObjectContainsCode(ObjectInfo object)
   {
      // Confirmation if control contains code
      if(object.instCode)
      {
         MembersInit members;
         if(object.instCode.members)
         {
            for(members = object.instCode.members->first; members; members = members.next)
            {
               if(members.type == methodMembersInit)
               {
                  //if(!Code_IsFunctionEmpty(members.function))
                  {
                     return true;
                  }
               }
            }
         }
      }
      return false;
   }

   void DeleteObject(ObjectInfo object)
   {
      if(codeEditor)
         codeEditor.DeleteObject(object);
   }

   void RenameObject(ObjectInfo object, const char * name)
   {
      if(object && (name || !object.classDefinition))
         codeEditor.RenameObject(object, name);
   }

   bool FindObject(Instance * object, const char * string)
   {
      ObjectInfo classObject;
      for(classObject = codeEditor.classes.first; classObject; classObject = classObject.next)
      {
         ObjectInfo check;
         if(classObject.name && !strcmp(string, classObject.name))
         {
            *object = classObject.instance;
            break;
         }
         for(check = classObject.instances.first; check; check = check.next)
         {
            if(check.name && !strcmp(string, check.name))
            {
               *object = check.instance;
               break;
            }
         }
         if(check)
            return true;
      }
      return false;
   }

   void SelectObjectFromDesigner(ObjectInfo object)
   {
      codeEditor.SelectObjectFromDesigner(object);
   }

   borderStyle = sizable;
   isActiveClient = true;
   hasVertScroll = true;
   hasHorzScroll = true;
   hasClose = true;
   hasMaximize = true;
   hasMinimize = true;
   text = $"Designer";
   menu = Menu { };
   anchor = Anchor { left = 300, right = 150, top = 0, bottom = 0 };

   ToolBox toolBox;
   CodeEditor codeEditor;

   Menu fileMenu { menu, $"File", f };
   MenuItem fileSaveItem
   {
      fileMenu, $"Save", s, ctrlS;
      bool NotifySelect(MenuItem selection, Modifiers mods)
      {
         return codeEditor.MenuFileSave(selection, mods);
      }
   };
   MenuItem fileSaveAsItem
   {
      fileMenu, $"Save As...", a;
      bool NotifySelect(MenuItem selection, Modifiers mods)
      {
         return codeEditor.MenuFileSaveAs(selection, mods);
      }
   };
   bool debugClosing;

   bool OnClose(bool parentClosing)
   {
      if(!parentClosing)
      {
         if(codeEditor && codeEditor.inUseDebug && !debugClosing)
         {
            debugClosing = true;
            closing = false;
            if(CloseConfirmation(false))
            {
               visible = false;
               if(modifiedDocument)
                  OnFileModified({ modified = true }, null);
            }
            debugClosing = false;
            return false;
         }
         if(codeEditor && !codeEditor.closing && !debugClosing)
         {
            if(!codeEditor.visible)
            {
               if(!codeEditor.Destroy(0))
                  return false;
               else
                  codeEditor = null;
            }
            else
            {
               visible = false;
               return false;
            }
         }
      }
      return true;
   }

   bool OnActivate(bool active, Window previous, bool * goOnWithActivation, bool direct)
   {
      if(active)
      {
         codeEditor.EnsureUpToDate();
         codeEditor.fixCaret = true;
         /*
         if(classDesigner)
            classDesigner.Activate();
         */
      }
      return true;
   }

   bool OnKeyHit(Key key, unichar ch)
   {
      return codeEditor.sheet.OnKeyHit(key, ch);
   }

   watch(modifiedDocument)
   {
      fileSaveItem.disabled = !modifiedDocument && codeEditor.fileName;
   };

   // *** METHODS ACCESSED FROM PROPERTY SHEET/TOOLBOX/CODE EDITOR ***
   void Reset()
   {
      if(classDesigner)
      {
         classDesigner.Reset();
         classDesigner.SelectObject(null, null);
         classDesigner.Destroy(0);
         delete classDesigner;
      }
   }

   void FillToolBox()
   {
      if(this && classDesigner)
         classDesigner.ListToolBoxClasses(this);
   }

   void SelectObject(ObjectInfo object, Instance instance)
   {
      ClassDesignerBase classDesigner = this.classDesigner;
#ifdef _DEBUG
      if(instance && instance._class.module.application != codeEditor.privateModule)
         printf("warning: SelectObject: instance._class.module.application != codeEditor.privateModule\n");
#endif
      if(!classDesigner || !instance || classDesigner._class != (Class)eInstance_GetDesigner(instance))
      {
         if(classDesigner)
         {
            classDesigner.SelectObject(null, null);
            classDesigner.Destroy(0);
            classDesigner = null;
            delete this.classDesigner;
         }
         if(instance)
         {
            this.classDesigner = classDesigner = eInstance_New(eInstance_GetDesigner(instance));
            incref classDesigner;
            //if(!classDesigner.parent)
            {
               classDesigner.parent = this;
               classDesigner.anchor = Anchor { left = 0, right = 0, top = 0, bottom = 0 };
            }
            classDesigner.Create();
         }
      }
      // Call class editor SelectObject
      if(classDesigner)
         classDesigner.SelectObject(object, instance);
   }

   void AddObject()
   {
      // Call class editor AddObject
      if(classDesigner)
         classDesigner.AddObject();
      if(visible)
         Activate();
      else
         codeEditor.Activate();
   }

   void CreateObject(Instance instance, ObjectInfo object, bool isClass, Instance iclass)
   {
      subclass(ClassDesignerBase) designerClass = eInstance_GetDesigner(instance);

      // Call class editor CreateObject
      if(designerClass)
         designerClass.CreateObject(this, instance, object, isClass, iclass);
   }

   void ::PostCreateObject(Instance instance, ObjectInfo object, bool isClass, Instance iclass)
   {
      subclass(ClassDesignerBase) designerClass = eInstance_GetDesigner(instance);

      // Call class editor PostCreateObject
      if(designerClass)
         designerClass.PostCreateObject(instance, object, isClass, iclass);
   }

   void ::DroppedObject(Instance instance, ObjectInfo object, bool isClass, Instance iclass)
   {
      subclass(ClassDesignerBase) designerClass = eInstance_GetDesigner(instance);

      // Call class editor PostCreateObject
      if(designerClass)
         designerClass.DroppedObject(instance, object, isClass, iclass);
   }

   void PrepareTestObject(Instance instance)
   {
      subclass(ClassDesignerBase) designerClass = eInstance_GetDesigner(instance);
      if(designerClass)
         designerClass.PrepareTestObject(this, instance);
   }

   void ::DestroyObject(Instance instance)
   {
      subclass(ClassDesignerBase) designerClass = eInstance_GetDesigner(instance);
      if(designerClass)
         designerClass.DestroyObject(instance);
   }

   void ::FixProperty(Property prop, Instance instance)
   {
      subclass(ClassDesignerBase) designerClass = eInstance_GetDesigner(instance);
      if(designerClass)
         designerClass.FixProperty(prop, instance);
   }
}

Example from Wikipedia:

import "ecere"

class HelloForm : Window
{
   caption = "My First eC Application";
   borderStyle = sizable;
   clientSize = { 304, 162 };
   hasClose = true;

   Label label
   {
      this, position = { 10, 10 }, font = { "Arial", 30 },
      caption = "Hello, World!!"
   };
};

HelloForm hello { };

Feature	Supported	Token	Example
Booleans	✓	true false
Strings	✓	"	"Hello world"
MultiLine Comments	✓	/* */	/* A comment */
Print() Debugging	✓	PrintLn
Comments	✓		// A comment
Line Comments	✓	//	// A comment
Semantic Indentation	X

eC

eC - Programming language

Language features