مرجع استخدام لغة الأسُس

إفتح الكل   أغلق الكل

يضم هذا المرجع تعليمات البرمجة الإجرائية باستخدام مكتبة نمط البرمجة المعياري (Standard Programming Paradigm).

مفاهيم عامة

المعرّفات (identifiers)

المعرّفات تستخدم للإشارة إلى دالة أو متغير أو صنف وتبدأ بحرف هجائي عربي أو انجليزي أو بالرمز _. يمكن للمعرفات أن تحتوي أيضاً على الأرقام 0-9 وعلى الحركات والشدّة أيضاً.

الفصل بين الجمل

تستخدم الفاصلة المنقوطة للفصل بين الجمل بطريقة مشابهة للفاصلة الإعتيادية التي تفصل بين الحدود داخل القوائم. بمعنى آخر فإن الفاصلة المنقوطة ليست جزءاً من الجملة ويُمكن إهمالها إن لم يأت بعدها جملة أخرى.

الأقواس الهلالية والأقواس المعقوفة

تستخدم الأقواس الهلالية في الأمور التي تُعالج أثناء تنفيذ البرنامج مثل جمع الحدود داخل التراكيب أو إرسال المدخلات إلى الدالّات، بينما تستخدم الأقواس المعقوفة في الأمور التي تُعالج أثناء الترجمة مثل تحديد نوع المؤشر أو المصفوفة. بمعنى آخر، إن كانت المعلومة مرسلةً إلى المترجم نفسه تُسخدم الأقواس المعقوفة، وإلا فالأقواس الهلالية.

الأقواس الحاصرة

تستخدم الأقواس الحاصرة لحصر مجموعة من الجمل في كتلة واحدة. وتستخدم هذه الكتل في جواب الجمل الشرطية ومتون الحلقات والهياكل والدالات والوحدات.

التعريفات

كل التعريفات تتم باستخدام الأمر "عرّف" (def) ويأخذ الصيغة التالية:
  عرّف <معرِّف> : <تعريف>
  def <identifier> : <definition>
التعريف يمكن أن يكون اسم أحد الأصناف وينتج عن التعريف متغير من ذلك الصنف، أو يكون أحد الأوامر التعريفية الأخرى مثل الدالات والهياكل. المثال التالي يعرّف متغيراً من صنف الأعداد الصحيحة:
  عرّف م : العدد_الصحيح
  def i : Int
يمكن أيضاً تعريف الثوابت بنفس الطريقة وذلك بوضع القيمة نفسها بدل الصنف ويمكن هذا مع الأعداد الصحيحة والعائمة بالإضافة إلى سلاسل المحارف، كما في المثال التالي:
  عرّف البسملة: "بسم الله الرحمن الرحيم"؛
  عرف النسبة_الثابتة: 3.141592؛
  عرف عدد_أيام_الاسبوع: 7؛
  def hello: "Hello World";
  def pi: 3.141592;
  def daysPerWeek: 7;

الهيكل العام للبرنامج

كل برنامج بلغة الأسُس يجب أن يشمل المكتبة "libalusus_spp.so" إما بشكل مباشر أو بشكل غير مباشر وذلك لأن هذه المكتبة هي التي تحتوي على تعريفات الأوامر الأساسية المتعلقة بالبرمجة الإجرائية. لذلك يبدأ كل برنامج بالأمر "اشمل" أو "import".
  import "libalusus_spp.so";
غالباً لن تحتاج لشمل مكتبة البناء المعيارية مباشرة، وإنما تشمل ملفات تعريفية أخرى تقوم بدورها بشمل مكتبة البناء المعيارية. على سبيل المثال:
  import "Srl/Console.alusus";
أو:
  اشمل "مـتم/طـرفية.أسس"؛
يحتوي كل برنامج على تعريف لوحدة وهذه الوحدة هي التي تحتوي على تعريفات البرنامج.
  def HelloWorld : module
  {
    ...
  }
  عرّف الـبسملة : وحدة
  {
    ...
  }
بعد ذلك يجب أن يضم البرنامج الأمر نفّذ (run) لتنفيذ البرنامج. السبب في ذلك يكمن في قدرة المبرمج على الاختيار بين التنفيذ المباشر (JIT compilation) أو التحويل إلى ملف تشغيلي (عبر الأمر build). خاصية التحويل إلى ملف تنفيذي ليست مكتملة بعد وسيتم إكمالها في إصدار آخر. الأمر "نفّذ" يكتب بالشكل التالي:
  نفّذ <اسم_وحدة>.<اسم_الدالة>؛
  run <module_name>.<function_name>

التعليقات

التعليقات في لغة الأسُس تبدأ بالرمز // وتنتهي عند نهاية السطر، أي أنها مشابهة للتعليقات مفردة السطر (single line comment) في لغة سي++ أو جافا.

الأصناف الأساسية للمتغيرات

  • صـحيح (Int)
    عدد صحيح. يتم تحديد عدد البتات بين أقواس معقوفة. تحديد عدد البتات اختياري وبدونه يكون العدد الافتراضي للبتات 32.
    صـحيح // 32 بتة
    صـحيح[1]
    صـحيح[8]
    صـحيح[16]
    صـحيح[32]
    صـحيح[64]
    
    Int // 32 bits
    Int[1]
    Int[8]
    Int[16]
    Int[32]
    Int[64]
    

  • طـبيعي (Word)
    عدد صحيح موجب. يتم تحديد عدد البتات بين أقواس معقوفة. تحديد عدد البتات اختياري وبدونه يكون العدد الافتراضي للبتات 32.
    طـبيعي // 32 بتة
    طـبيعي[1]
    طـبيعي[8]
    طـبيعي[16]
    طـبيعي[32]
    طـبيعي[64]
    
    Word // 32 bits
    Word[1]
    Word[8]
    Word[16]
    Word[32]
    Word[64]
    

  • عـائم (Float)
    عدد عائم. يتم تحديد عدد البتات بين أقواس معقوفة. تحديد عدد البتات اختياري وبدونه يكون العدد الافتراضي للبتات 32.
    عـائم // 32 بتة
    عـائم[32]
    عـائم[64]
    
    Float // 32 bits
    Float[32]
    Float[64]
    

  • مـحرف (Char)
    محرف، وهو مجرد لقب للصنف `طـبيعي[8]`.

  • ثـنائي (Bool)
    قيمية ثنائية، وهو مجرب لقب للصنف `طـبيعي[1]`.

  • مصفوفة (array)
    مصفوفة من المتغيرات. تُعرف بتحديد صنف المتغيرات وعدد الخانات بين أقواس معقوفة كما يلي:
    مصفوفة[الصنف، عدد_الخانات]
    
    array[the_type, element_count]
    

  • مؤشر (ptr)
    مؤشر إلى متغير. صنف المتغير يحدد بين أقواس معقوفة، كما يلي:
    مؤشر[الصنف]
    
    ptr[the_type]
    

التراكيب والمؤثرات

المؤثرات

فيما يلي قائمة المؤثرات مرتبة تصاعدياً حسب الأسبقية، أي أن العناصر الأولى بأسبقية أقل:
ملاحظة: بعض هذه المؤثرات غير مدعومة بعد وسيتم دعمها في إصدار لاحق.
  • مؤثرات التعيين
    =تحديد قيمة جديدة
    +=إضافة قيمة للقيمة الحالية
    -=طرح قيمة من القيمة الحالية
    *=ضرب القيمة الحالية بقيمة أخرى
    /=تقسيم القيمة الحالية على قيمة أخرى
    %=تقسيم القيمة الحالية على قيمة أخرى والاحتفاظ بالباقي بدل نتيجة القسمة
    &=تطبيق عملية 'و' المنطقية على القيمة الحالية
    |=تطبيق عملية 'أو' المنطقية على القيمة الحالية
    $=تطبيق عملية xor المنطقية على القيمة الحالية
    <<=تزحيف جميع البتّات يساراً مراتباَ بتعداد القيمة المعطاة
    =>>تزحيف جميع البتّات يميناً مراتباً بتعداد القيمة المعطاة
  • مؤثرات العمليات المنطقية
    وعملية `و` المنطقية، ويمكن كتابتها and ايضاً
    أوعملية `أو` المنطقية، ويمكن كتابتها or أيضاً
    ||صيغة رمزية ل or
    &&صيغة رمزية ل and
  • مؤثرات المقارنة
    ==فحص مساواة
    !=فحص عدم المساواة
    <فحص أصغر
    >فحص أكبر
    <=فحص أصغر أو يساوي
    >=فحص أكبر أو يساوي
  • مؤثرات الجمع والطرح
    +
    -
  • مؤثرات الضرب والقسمة
    *
    /
    %تحصيل باقي القسمة
  • مؤثرات العمليات البتّية
    هذه المؤثرات لتطبيق عمليات منطقية على مستوى البتّات، أي تطبيق العمليات على كل بت وما يقابله، بالإضافة إلى عمليات تزحيف البتّات.
    |عملية 'أو'
    $عملية xor
    &عملية 'و'
    <<تزحيف البتّات يميناً مراتباً بتعداد القيمة المعطاة
    >>تزحيف البتّات يساراً مراتباً بتعداد القيمة المعطاة
  • المؤثرات الأحادية السابقة
    ++زيادة بواحد
    --إنقاص بواحد
    +إشارة الرقم الموجب
    -إشارة الرقم السالب
    !علامة النفي البتّية (عكس قيمة البتّات)
    !!علامة النفي المنطقية
  • المؤثرات الأحادية اللاحقة
    ++زيادة بواحد
    --إنقاص بواحد

التحكم بالأسبقية

تستخدم الأقواس الهلالية للتحكم بالأسبقية في التراكيب. على سبيل المثال التركيب التالي ينفذ عملية الضرب قبل الجمع:
  س = ص + ع * م
بينما التركيب التالي ينفذ الجمع قبل الضرب:
  س = (ص + ع) * م

الرموز الحرفية

بالإضافة للمتغيرات، بالإمكان استخدام الرموز الحرفي في التراكيب. وهذه قائمة الرموز الحرفية المدعومة في لغة الأسُس:
  • الأعداد الصحيحة
    تكتب كعدد عشري وتُمثل ب32 بت. مثلا: 132
  • أعداد الفاصلة العائمة
    تكتب كعدد حقيقي وتُمثل ب32 بت. مثلا: 1.32
  • سلاسل المحارف
    سلاسل المحارف تُحصر بعلامتي اقتباس، كما في المثال التالي:
      "بسم الله الرحمن الرحيم"
    
    يمكن كتابة الرموز الخاصة باستخدام علامة \ وفيما يلي قائمة الرموز الخاصة:
    \nبداية سطر جديد
    \rرجوع إلى بداية السطر
    \tإدراج علامة تاب (tab)
    \"إدراج علامة اقتباس
    \\إدراج علامة \

أوامر التحكم

الجمل الشرطية

تكتب الجمل الشرطية بالصيغة التالية:
  إذا <تركيب شرطي> <جملة>
  إذا <تركيب شرطي> { <مجموعة جمل> }
  إذا <تركيب شرطي> <جملة_أو_كتلة> وإلا <جملة_أو_كتلة>
  if <condition expression> <statement>
  if <condition expression> { <group of statements> }
  if <condition expression> <statement_or_block> else <statement_or_block>
ليس مشروطاً حصر تركيب الشرط بأقواس هلالية لكن ذلك متاح.

الحلقات

تكتب الحلقات بالصيغ التالية:
  بينما <تركيب شرطي> <جملة>
  بينما <تركيب شرطي> { <مجموعة جمل> }
  لكل <تهيئة عداد>، <تركيب شرطي>، <تحديث عداد> <جملة>
  لكل <تهيئة عداد>، <تركيب شرطي>، <تحديث عداد> { <مجموعة جمل> }
  while <condition expression> <statement>
  while <condition expression> { <group of statements> }
  for <counter initialization>, <condition expression>, <counter update> <statement>
  for <counter initialization>, <condition expression>, <counter update> { <group of statement> }
مثلما هو الحال مع الجمل الشرطية، ليس مشترطاً حصر التركيب الشرطي في "بينما" أو التراكيب الثلاث المتعلقة بالعداد في "لكل" بأقواس هلالية، لكن ذلك متاح. مثال:
  بينما ن!=0 ن=قم_بعملية()؛
  بينما ن!=0 { ن = قم_بعملية() }؛
  لكل ع=0، ع<10، ع++ اطبع("%d\ج"، ع)؛
  لكل (ع=0، ع<10، ع++) اطبع("%d\ج"، ع)؛
  لكل ع=0، ع<10، ع++ { اطبع("%d\ج"، ع) }؛
  while r!=0 r=performOperation();
  while r!=0 { r = performOperation() }
  for i=0, i<10, i++ print("%d\n", i);
  for (i=0, i<10, i++) print("%d\n", i);
  for i=0, i<10, i++ { print("%d\n", i) };

الأمر `أكمل` (continue)

يستخدم لتجاوز ما تبقى من الدورة الحالية للحلقة والبدء بدورة جديدة. يمكن تحديد رقم الحلقة المراد تجاوز دورتها في حالة الحلقات المتداخلة.
  أكمل؛ // بدء دورة جديدة من الحلقة الحالية.
  أكمل 2؛ // الخروج من الحلقة الحالية وبدء دورة جديدة من الحلقة الخارجية.
  continue;
  continue 2;

الأمر `اقطع` (break)

الخروج من الحلقة. يمكن تحديد رقم الحلقة المراد الخروج منها في حالة الحلقات المتداخلة.
  اقطع؛ // الخروج من الحلقة الحالية.
  اقطع 2؛ // الخروج من الحلقة الحالية والخارجية
  break;
  break 2;

الدالّات

تعرّف الدالات باستخدام الأمر "دالّة" كتعريف في الأمر "عرّف":
  عرّف <اسم_الدالة> : دالّة (<معطيات>) => <صنف_النتيجة> { <متن_الدالة> }
  def <func name> : function (<arguments>) => <return_type> { <function_body> }
وتكون المعطيات بالصيغة التالية:
  <اسم_المعطى>:<نوع_المعطى>، <اسم_المعطى>:<نوع_المعطى> ...
  <arg_name>:<arg_type>, <arg_name>:<arg_type> ...
كما في المثال التالي:
  عرف مضروب : دالّة (ع:العدد_الصحيح) => العدد_الصحيح
  {
    إذا ع==1 أرجع 1؛
    أرجع ع * مضروب(ع-1)؛
  }
  def factorial : function (i:Int) => Int
  {
    if i==1 return 1;
    return i*factorial(i-1);
  }
يمكن أيضًا استخدام الصيغة المختصرة دون الحاجة للأمر "عرف" كما لي:
  دالة <اسم_الدالة> (<معطيات>) => <صنف_النتيجة> { <متن_الدالة> }
  function <func name> (<arguments>) => <return_type> { <function_body> }
كما في المثال التالي:
  دالة مضروب (ع:العدد_الصحيح) => العدد_الصحيح
  {
    إذا ع==1 أرجع 1؛
    أرجع ع * مضروب(ع-1)؛
  }
  function factorial (i:Int) => Int
  {
    if i==1 return 1;
    return i*factorial(i-1);
  }
استدعاء الدوال يتم باستخدام اسم الدالة يليه قائمة المعطيات بين قوسين هلاليين. إن لم تكن للدالة أي معطيات فيجب إتباع اسمها بقوسين هلاليين فارغين.
  س = إقرأ_رقماً()؛
  ص = إقرأ_رقماً()؛
  ارسم_نقطة(س، ص)؛
  x = readNumber();
  y = readNumber();
  drawPoint(x, y);

أصناف المستخدم

تعرّف الهياكل باستخدام الأمر "صنف" كتعريف في الأمر "عرّف":
  عرّف <اسم_الصنف> : صنف { <مجموعة_تعريفات> }
  def <type_name> : type { <definition_statements> }
بعد تعريف الصنف يصبح الصنف متوفراً لتعريف المتغيرات. الولوج إلى عناصر الهيكل يتم باستخدام مؤثر النقطة. مثال:
  عرّف النقطة : صنف {
    عرّف س : العدد_الحقيقي؛
    عرّف ص : العدد_الحقيقي؛
  }؛
  .
  .
  عرّف ن : النقطة؛
  ن.س = إقرأ_قيمة()؛
  ن.ص = إقرأ_قيمة()؛
  def Point : type {
    def x : Float;
    def y : Float
  };
  .
  .
  def p : Point;
  p.x = readValue();
  p.y = readValue();
يمكن أيضًا استخدام الصيغة المختصرة التي تغنيك عن استعمال الأمر "عرف"، كما يلي:
  صنف <اسم_الصنف> { <مجموعة_تعريفات> }
  type <type_name> { <definition_statements> }
كما في المثال التالي:
  صنف النقطة {
    عرّف س : العدد_الحقيقي؛
    عرّف ص : العدد_الحقيقي؛
  }؛
  .
  .
  عرّف ن : النقطة؛
  ن.س = إقرأ_قيمة()؛
  ن.ص = إقرأ_قيمة()؛
  type Point {
    def x : Float;
    def y : Float
  };
  .
  .
  def p : Point;
  p.x = readValue();
  p.y = readValue();

المؤشرات

المؤشرات تستخدم للإشارة إلى مواقع في الذاكرة والتحكم بمحتويات تلك المواقع. تُعرّف المؤشرات باستخدام الصنف "مؤشر" (ptr) متبوعاً بقوسين معقوفين بينهما صنف محتوى الذاكرة المشار إليه بالمؤشر:
  عرّف <اسم_المؤشر> : مؤشر[<صنف_المحتوى>]
  def <ptr_name> : ptr[<content_type>]
يمكن الولوج إلى المحتوى المشار إليه بالمؤشر عن طريق المؤثر "~محتوى" (~cnt) ويمكن الحصول على موقع أي متغير عن طريق المؤثر "~مؤشر" (~ptr) كما في المثال التالي:
  عرّف م : مؤشر[العدد_الصحيح]؛
  عرّف س : العدد_الصحيح؛
  س = 5؛
  م = س~مؤشر؛
  م~محتوى = 1؛
  // قيمة س الآن 1 وليس 5.
  def p : ptr[Int];
  def x : Int;
  x = 5;
  p = x~ptr;
  p~cnt = 1;
  // x is now equal to 1, not 5.

المصفوفات

تعرّف المصفوفات باستخدام الصنف "مصفوفة" (array) متبوعاً بأقواس معقوفة تحتوي صنف عناصر المصفوفة وعددها:
  عرّف <اسم_المصفوفة> : مصفوفة[<صنف_العناصر>، <عدد_العناصر>]
  def <array_name> : array[<element_type>, <element_count>]
يمكن الدخول إلى عناصر المصفوفة بإعطاء رقم العنصر المعني بين قوسين معقوفين. مثال:
  عرّف مصفوفتي : مصفوفة[صحيح، 10]؛
  عرّف ع : صحيح؛
  لكل ع=0، ع<10، ع++ {
    مصفوفتي[ع] = مضروب(ع)
  }
  def myArray : array[Int, 10];
  def i : Int;
  for i=0, i<10, i++ {
    myArray[i] = factorial(i)
  }

تمثيل الأصناف

يمكن تمثيل المتغيرات بصنف غير صنفها الحقيقي باستخدام المؤثر "~مثّل" (~cast) متبوعاً بقوسين معقوفين بينهما الصنف المراد تمثيله، كما في المثال التالي:
  عرّف ح : عـائم؛
  إطبع_عددا_صحيحا(ح~مثّل[صحيح])؛
  def f : Float;
  printInteger(f~cast[Int]);
في الوقت الحالي عملية التمثيل محدودة ومازالت قيد التطوير، لكنها قريباً ستدعم تمثيل الأصناف دون قيود، مثل تمثيل عدد صحيح كمؤشر أو تمثيل مؤشر لصنف ما كمؤشر لصنف آخر.

الألقاب

لتيسير استخدام المكتبات المكتوبة بالانجليزية داخل برامج مكتوبة بالعربية (أو العكس) يمكن إنشاء ألقاب للدالّات والأصناف والمتغيرات وذلك باستخدام الأمر "لقب" (alias) كتعريف للأمر "عرّف". بعد ذلك يمكن استخدام الأسم الأصلي أو اللقب كيفما يشاء المستخدم فكلاهما يشيران إلى نفس المعرّف. على سبيل المثال الصنف "العدد_الصحيح" هو لقب للصنف "Int" والدالة "اطبع" هي لقب للدالة "printf" وقد تم تعريف هذه الألقاب مسبقاً في الملف "متم.أسس" كما يلي:
  عرّف العدد_الصحيح : لقب int؛
  عرّف اطبع : لقب printf؛
إنشاء الألقاب لا يشترط أن يكون بين لغتين، فيمكن تعريف لقب انجليزي لمعرّف انجليزي على سبيل المثال، كما في الصنف Int الذي هو لقب لـint.

الوحدات

الوحدة مجال يمكن وضع التعريفات داخله. يمكن للوحدة أن تحتوي دالات أو متغيرات أو أصناف كما يمكن للوحدة أن تحتوي وحدات أخرى. تساعد الوحدات في تجنب الاصطدام الناتج من التشابه بين أسماء التعريفات حيث أن التعريفات داخل أي وحدة غير مرئية داخل الوحدات الأخرى ما لم تتم الإشارة إليها بشكل صريح.
يمكن تعريف الوحدة باستخدام الأمر `وحدة` (module) كما يلي:
  عرّف <اسم_الوحدة> : وحدة { <التعريفات> }؛
  def <module_name> : module { <definitions> };
يمكن الوصول إلى تعريفات داخل وحدة أخرى بأحد الطرق التالية:
  • أن تكون الوحدة الحالية نفسها داخل الوحدة التي تحتوي التعريف المطلوب كما في المثال التالي:
      عرف الـخارجية: وحدة {
        عرف م: صـحيح؛
    
        عرف الـداخلية: وحدة {
          عرف اطبع_م: دالة {
            اطبع(م)؛
          }
        }
      }
    
      def Outer: module {
        def v: Int;
    
        def Inner: module {
          def printV: function {
            print(v);
          }
        }
      }
    
  • أن يتم ذكر المجال الكامل للتعريف المراد الوصول إليه، ابتداءًا من أي مجال مشترك كما في المثال التالي:
      عرف الـخارجية: وحدة {
        عرف الـداخلية1: وحدة {
          عرف م: صـحيح؛
        }؛
    
        عرف الـداخلية2: وحدة {
          عرف اطبع_م: دالة {
            اطبع(الـداخلية1.م)؛
          }
        }
      }
    
      def Outer: module {
        def Inner1: module {
          def v: Int;
        };
    
        def Inner2: module {
          def printV: function {
            print(Inner1.v);
          }
        }
      }
    
  • باستخدام الأمر `استخدم` (use). يستخدم هذا الأمر لجعل مجال معين متوفرًا داخل المجال الحالي وصيغته كما يلي:
      استخدم <المجال_الكامل_للوحدة_المستهدفة>؛
    
      use <full_path_of_targetted_module>;
    
    هذا الأمر مفيد لتجنب الحاجة لتكرار ذكر المجال الكامل. يمكن استخدام هذا الأمر داخل وحدة أخرى أو داخل دالة ولا يمكن استخدامه في المجال الرئيسي خارج الوحدات. المثال التالي يوضح استخدام الأمر:
      عرف الـخارجية: وحدة {
        عرف الـداخلية1: وحدة {
          عرف الـداخلية2: وحدة {
            عرف م: صـحيح؛
          }؛
        }؛
    
        استخدم الـداخلية1.الـداخلية2؛
    
        عرف اطبع_م: دالة {
          اطبع(م)؛
        }
      }
    
      def Outer: module {
        def Inner1: module {
          def Inner2: module {
            def v: Int;
          };
        };
    
        use Inner1.Inner2;
    
        def printV: function {
          print(v);
        }
      }
    
يمكن أيضًا استخدام الصيغة المختصرة التي تغنيك عن الأمر "عرف":
  وحدة <اسم_الوحدة> { <التعريفات> }؛
  module <module_name> { <definitions> };
كما في المثال التالي:
  وحدة الـخارجية {
    وحدة الـداخلية1 {
      وحدة الـداخلية2 {
        عرف م: صـحيح؛
      }؛
    }؛
  }
  module Outer {
    module Inner1 {
      module Inner2 {
        def v: Int;
      };
    };
  }

الماكروهات

الماكرو هو مجموعة من الأوامر يمكن تكرارها بسهولة في أي مكان من البرنامج. يتم تعريف الماكرو كما يلي:
  عرّف <اسم_الماكرو> : ماكرو [<قائمة_المدخلات>] <متن_الماكرو>
  def <macro_name> : macro [<arg_list>] <macro_body>
متن الماكرو يمكن أن يكون سطراً واحداً أو مجموعة أسطر بين أقواس حاصرة. ثم يُستخدم الماكرو لاحقاً في البرنامج بكتابة اسمه متبوعاً بالمعطيات بين أقواس معقوفة، كما في المثال التالي:
  عرّف تربيع: ماكرو [م] م * م؛
  .
  .
  ص = تربيع[س]؛
  def power2: macro [n] n * n;
  .
  .
  s = power2[a];
يمكن كذلك استخدام الصيغة المختصرة التي تغنيك عن استخدام الأمر "عرف":
  ماكرو <اسم_الماكرو> [<قائمة_المدخلات>] <متن_الماكرو>
  macro <macro_name> [<arg_list>] <macro_body>
كما في المثال التالي:
  ماكرو تربيع [م] م * م؛
  .
  .
  ص = تربيع[س]؛
  macro power2 [n] n * n;
  .
  .
  s = power2[a];

القوالب في المعرفات وسلاسل المحارف

يمكن استخدام القوالب مع المعرفات وسلاسل المحارف داخل الماكرو ويتم ذلك في المعرفات بحصر القسم المتغير من المعرف بين شارحتين سفليتين متتاليتين من كل جانب، أما في سلاسل المحارف فيتم حصر القسم المتغير بين قوسين حاصرين مزدوجين، كما في المثال التالي:
  عرّف اطبع_متغيرات: ماكرو [م] {
    اطبع("{{م}}1 = %d\ج"، __م__1)؛
    اطبع("{{م}}2 = %d\ج"، __م__2)؛
  }؛
  .
  .
  س1 = 5؛
  س2 = 6؛
  اطبع_متغيرات[س]؛

  // سيطبع التالي:
  //  س1 = 5
  //  س2 = 6
  def print_vars: macro [v] {
    print("{{v}}1 = %d\n", __v__1);
    print("{{v}}2 = %d\n", __v__2);
  };
  .
  .
  s1 = 5;
  s2 = 6;
  print_vars[s];

  // will print:
  //  s1 = 5
  //  s2 = 6

الفرق بين ماكرو لغة الأسُس وماكرو لغة السي

الماكرو في لغة الأسُس مختلف عن نظيره في لغة السي في طريقة المعالجة. في لغة السي الماكرو يعالج نصياً في مرحلة تسبق الإعراب بينما في لغة الأسُس الماكرو يعالج أثناء مرحلة الإعراب نفسها وهذا يؤدي إلى الفروقات التالية:
  • في لغة الأسُس الماكرو تأثيره محدود ضمن مجال تعريفه بعكس الماكر في لغة السي حيث يكون غير محدود بأي مجال. بمعنى آخر، في لغة الأسُس إذا عرفت ماكرو داخل مجال معين وحاولت استخدامه داخل مجال آخر فسيمنعك المترجم من ذلك.
  • يمكن في لغة الأسُس تعريف عدة ماكروهات بنفس الاسم طالما أنها معرفة ضمن مجالات مختلفة، وهذا غير ممكن في لغة السي.
  • في لغة الأسُس الأخطاء الإعرابية داخل الماكرو يتم استشعارها مباشرة بعكس لغة السي حيث لا تُستشعر الأخطاء الإعرابية إلا بعد انتهاء معالجة الماكرو والبدء بمرحلة الإعراب.
  • في لغة الأسُس لا يمكن تعريف ماكرو يحتوي متنه على أجزاء غير مكتملة من القواعد بعكس لغة السي التي تتيح ذلك. مثلاً، في لغة السي يمكن تعريف ماكرو يحتوي على جزء غير مكتمل من القواعد ويقوم المستخدم يتجميع ماكروهات متعددة للحصول على برنامج صحيح قواعدياً وهذا الأمر غير ممكن في لغة الأسُس التي تمنع أن يكون متن أي ماكرو غير مكتمل قواعدياً.

تجزئة التعريفات

بعض التعريفات يمكن تجزئتها إلى عدة أجزاء تدمج لاحقاً عند البناء في تعريف واحد. تمكن هذه الخاصية المستخدم من توزيع التعريفات الكبيرة مثل الوحدات إلى عدة ملفات كما تمكن أيضاً من إلحاق إضافات إلى تعريفات مسبقة. تتم التجزئة باستخدام المبدل `@دمج` (@merge) كما في المثال التالي:
  عرف نـقطة: صنف {
    عرف س: صـحيح؛
  }؛
  .
  .
  @دمج عرف نـقطة: صنف {
    عرف ص: صحيح؛
  }؛
  .
  .
  عرف ابدأ: دالة {
    عرف ن: نـطقة؛
    ن.س = 10؛
    ن.ص = 12؛
    .
    .
  }؛
  def Point: type {
    def x: Int;
  };
  .
  .
  @merge def Point: type {
    def y: Int;
  };
  .
  .
  def start: function {
    def p: Point;
    p.x = 10;
    p.y = 12;
    .
    .
  };

شمل مكتبات أو ملفات مصدرية

الأمر "اشمل" (import) يستخدم لتحميل ملف مصدري أو مكتبة واستخدامها في البرنامج. الأمر يميز تلقائياً بين الملف المصدري والمكتبة. في الوقت الحالي يدعم هذا الأمر ثلاث أنواع من الملفات: ملفات مصدرية ومكتبات متحركة (dynamic) عامة ومكتبات بناء مثل libalusus_scg. يمكن تحميل أي مكتبة متحركة مهما كانت اللغة التي كتبت بها وعند تحميلها تكون كل دالّاتها العمومية متوفرة للاستخدام من داخل برنامج الأسُس، لكن ستحتاج لتعريف تلك الدوال يدوياً باستخدام الأمر `دالة` مع إضافة المبدل `@تصدير` (@expname) كما هو مبين في المثال التالي:
  اشمل "libmath.so"؛
  عرف جا: @تصدير[sin] دالة (ر: عـائم) => عـائم؛
  .
  .
  ج = جا(ز)؛
  import "libmath.so";
  def sin: @expname[sin] function (f: Float) => Float;
  .
  .
  s = sin(r);

دليل المكتبات التنفيذية

دليل مكتبة التنفيذ المعيارية

مكتبة التنفيذ المعيارية تتكون من وحدة واحدة اسمها `مـتم` (Srl) وتحتوي هذه الوحدة على الوحدات التالية:

طـرفية (Console)

تحتوي وحدة `طـرفية` على الدالات التالية:
  • أدخل_محرفا (getChar)
    def getChar: @expname[getchar] function () => Int[32]
    
    مطابقة لدالة getchar من POSIX.

  • أخرج_محرفا (putChar)
    def putChar: @expname[putchar] function (character: Int[32]) => Int[32]
    
    مطابقة لدالة putchar من POSIX.

  • اطبع (print)
    1: def print: @expname[printf] function (format: ptr[Word[8]], args: ...any) => Int[32]
    2: def print: function (i: Int[64])
    3: def print: function (f: Float[64])
    4: def print: function (f: Float[64], d: Int)
    
    1: مطابقة لدالة printf من POSIX.
    2: تطبع عدداً صحيحاً.
    3: تطبع عدداً عائماً.
    4: تطبع عدداً عائماً مع تحكم بعدد الأصفار على يمين الفاصلة.

  • امسح (scan)
    def scan: @expname[scanf] function (format: ptr[Word[8]], args: ...any) => Int[32]
    
    مطابقة لدالة scanf من POSIX.

  • أدخل_صحيح (getInt)
    def getInt: function () => Int
    
    تطلب من المستخدم إدخال عدد صحيح.

  • أدخل_عائم (getFloat)
    def getFloat: function () => Float
    
    تطلب من المستخدم إدخال عدد بفاصلة عائمة.

  • أدخل_محارف (getString)
    def getString: function (str: ptr[array[Char]], count: Word) => Void
    
    تطلب من المستخدم إدخال سلسلة محارف.

طـراز (Style)
تحتوي وحدة 'طـراز' على دالات للتحكم بطراز الكتابة في الطرفية. كل واحدة من هذه الدالات ترجع مؤشراً على مصفوفة محارف يمكن طباعتها في الطرفية للحصول على الطراز المطلوب.
  • صفر (reset)
  • لقب (bright)
  • خافت (dim)
  • مائل (italic)
  • خط_تحتي (underscore)
  • وميض (blink)
  • عكس (reverse)
  • مخفي (hidden)
  • كتابة_سوداء (fgBlack)
  • كتابة_حمراء (fgRed)
  • كتابة_خضراء (fgGreen)
  • كتابة_صفراء (fgYellow)
  • كتابة_زرقاء (fgBlue)
  • كتابة_أرجوانية (fgMagenta)
  • كتابة_سماوية (fgCyan)
  • كتابة_بيضاء (fgWhite)
  • خلفية_سوداء (bgBlack)
  • خلفية_حمراء (bgRed)
  • خلفية_خضراء (bgGreen)
  • خلفية_صفراء (bgYellow)
  • خلفية_زرقاء (bgBlue)
  • خلفية_أرجوانية (bgMagenta)
  • خلفية_سماوية (bgCyan)
  • خلفية_بيضاء (bgWhite)

نـظام (System)

تحتوي وحدة `نـظام` على التعريفات التالية:
  • وقـت (Time)
    عرف وقـت: صنف
    {
      عرف ثانية: صـحيح؛
      عرف دقيقة: صـحيح؛
      عرف ساعة: صـحيح؛
      عرف يوم: صـحيح؛
      عرف شهر: صـحيح؛
      عرف سنة: صـحيح؛
      عرف يوم_اسبوعي: صـحيح؛
      عرف يوم_سنوي: صـحيح؛
      عرف إزاحة_زمنية: صـحيح؛
      عرف منطقة_زمنية: صـحيح؛
    }
    
    def Time: type
    {
      def second: Int;
      def minute: Int;
      def hour: Int;
      def day: Int;
      def month: Int;
      def year: Int;
      def weekDay: Int;
      def yearDay: Int;
      def daylightSaving: Int;
      def timezoneOffset: Int[64];
      def timezone: ptr[array[Char]];
    };
    
    سجل لحمل معلومات الوقت والتاريخ.

  • هات_الوقت_المفصل (getDetailedTime)
    1: def getDetailedTime: @expname[localtime] function (ts: ptr[Word[64]]) => ptr[Time];
    2: def getDetailedTime: @expname[localtime_r] function (ts: ptr[Word[64]], dt: ptr[Time]) => ptr[Time];
    
    1. مطابقة لدالة localtime من POSIX.
    2. مطابقة لدالة localtime_r من POSIX.

  • هات_الختم_الزمني (getTimestamp)
    def getTimestamp: @expname[time] function (r: ptr[Word[64]]) => Word[64];
    
    مطابقة لدالة time من POSIX.

  • نم (sleep)
    def sleep: @expname[usleep] function (d: Word) => Void;
    
    مطابقة لدالة usleep من POSIX.

  • اضبط_متغير_محيطي (setEnv)
    def setEnv: @expname[setenv] function (name: ptr[Word[8]], value: ptr[Word[8]], overwrite: Int) => Int;
    
    مطابقة لدالة setenv من POSIX.

  • هات_متغير_محيطي (getEnv)
    def getEnv: @expname[getenv] function (name: ptr[Word[8]]) => ptr[Word[8]];
    
    مطابقة لدالة getenv من POSIX.

  • شغل (exec)
    def exec: @expname[system] function (filename: ptr[Word[8]]) => Int;
    
    مطابقة لدالة system من POSIX.

ذاكـرة (Memory)

تحتوي وحدة `ذاكـرة` على الدالات التالية:
  • احجز (alloc)
    def alloc: @expname[malloc] function (size: Int[64]) => ptr[Void];
    
    مطابقة لدالة malloc من POSIX.

  • أعد_الحجز (realloc)
    def realloc: @expname[realloc] function (p: ptr[Void], newSize: Int[64]) => ptr[Void];
    
    مطابقة لدالة realloc من POSIX.

  • احجز_مرصوف (allocAligned)
    def allocAligned: @expname[aligned_alloc] function (alignment: Int[64], size: Int[64]) => ptr[Void];
    
    مطابقة لدالة aligned_alloc من POSIX.

  • حرر (free)
    def free: @expname[free] function (pointer: ptr[Void]);
    
    مطابقة لدالة free من POSIX.

  • انسخ (copy)
    def copy: @expname[memcpy] function (dest: ptr[Void], src: ptr[Void], n: Int[64]) => ptr[Void];
    
    مطابقة لدالة memcpy من POSIX.

  • قارن (compare)
    def compare: @expname[memcmp] function (s1: ptr[Void], s2: ptr[Void], n: Int[64]) => Int;
    
    مطابقة لدالة memcmp من POSIX.

  • اضبط (set)
    def set: @expname[memset] function (s: ptr[Void], c: Int, n: Int[64]) => ptr[Void];
    
    مطابقة لدالة memset من POSIX.

مـحارف (String)

تحتوي وحدة `مـحارف` على الدالات التالية:
  • جد_محرف (findChar)
    1: def findChar: @expname[strchr] function (s: ptr[Char], c: Int) => ptr[Char];
    2: def findChar: @expname[memchr] function (s: ptr[Void], c: Int, n: Int[64]) => ptr[Void];
    
    1. مطابقة لدالة strchr من POSIX.
    2. مطابقة لدالة memchr من POSIX.

  • جد_آخر_محرف (findLastChar)
    def findLastChar: @expname[strrchr] function (s: ptr[Char], c: Int) => ptr[Char];
    
    مطابقة لدالة strrchr من POSIX.

  • جد_محارف (findString)
    def findString: @expname[strstr] function (haystack: ptr[Char], needle: ptr[Char]) => ptr[Char];
    
    مطابقة لدالة strstr من POSIX.

  • قارن (compare)
    1: def compare: @expname[strcmp] function (s1: ptr[Char], s2: ptr[Char]) => Int;
    2: def compare: @expname[strncmp] function (s1: ptr[Char], s2: ptr[Char], n: Int[64]) => Int;
    
    1. مطابقة لدالة strcmp من POSIX.
    2. مطابقة لدالة strncmp من POSIX.

  • انسخ (copy)
    1: def copy: @expname[strcpy] function (dest: ptr[Char], src: ptr[Char]) => ptr[Void];
    2: def copy: @expname[strncpy] function (dest: ptr[Char], src: ptr[Char], n: Int[64]) => ptr[Void];
    
    1. مطابقة لدالة strcpy من POSIX.
    2. مطابقة لدالة strncpy من POSIX.

  • سلسل (concat)
    1: def concat: @expname[strcat] function (dest: ptr[Char], src: ptr[Char]) => ptr[Char];
    2: def concat: @expname[strncat] function (dest: ptr[Char], src: ptr[Char], n: Int[64]) => ptr[Char];
    
    1. مطابقة لدالة strcat من POSIX.
    2. مطابقة لدالة strncat من POSIX.

  • جد_طول (getLength)
    def getLength: @expname[strlen] function (s: ptr[Char]) => Int[64];
    
    مطابقة لدالة strlen من POSIX.
  • تعيين (assign)
    def assign: @expname[sprintf] function (target: ptr[Char], format: ptr[Word[8]], args: ...any) => Int[32];
    
    مطابقة لدالة sprintf من POSIX.
  • امسح (scan)
    def scan: @expname[sscanf] function (target: ptr[Char], format: ptr[Word[8]], args: ...any) => Int[32];
    
    مطابقة لدالة sscanf من POSIX.
  • تـطابقات_نمطية (RegexMatches)
    عرف تـطابقات_نمطية: صنف
    {
      عرف عدد: صـحيح؛
      عرف متطابقات: مصفوفة[مصفوفة[مـحرف، 10240]]؛
    }
    
    def RegexMatches: type {
      def count: Int;
      def matches: array[array[Char, 10240]];
    };
    
    سجل لحمل معلومات التطابقات النمطية.
  • انمط (regex)
    عرف انمط: دالة (نمط: مؤشر[مصفوفة[مـحرف]]، محارف: مؤشر[مصفوفة[مـحرف]]، وضع: صـحيح) => مؤشر[تـطابقات_نمطية]؛
    
    def regex: function(pattern: ptr[array[Char]], string: ptr[array[Char]], mode: Int) => ptr[RegexMatches];
    
    إجراء عملية بحث نمطية على سلسلة محارف.

نـم (Fs)

تحتوي وحدة `نـم` على الدالات والعناصر التالية للتعامل مع نظام الملفات:
  • قـيد_مجلد (DirEnt)
    عرف قـيد_مجلد: صنف
    {
      عرف نوع: صـحيح[8]؛
      عرف اسم: مصفوفة[مـحرف، 256]؛
    }
    
    def DirEnt: type {
      def dType: Int[8];
      def dName: array[Char, FILENAME_LENGTH];
    };
    
    سجل معلومات عنصر من عناصر المجلد.

  • اسـماء_ملفات (FileNames؛)
    عرف اسـماء_ملفات: صنف
    {
      عرف عدد: صـحيح؛
      عرف اسماء: مصفوفة[مصفوفة[مـحرف، 256]]؛
    }
    
    def FileNames: type
    {
      def count: Int;
      def names: array[array[Char, FILENAME_LENGTH]];
    };
    
    قائمة بأسماء ملفات.

  • انـتقال (Seek)
    عرف انـتقال: {
      عرف _بداية_: لقب 0؛
      عرف _حالي_: لقب 1؛
      عرف _نهاية_: لقب 2؛
    }؛
    
    def Seek: {
      def SET: 0;
      def CUR: 1;
      def END: 2;
    };
    
    ثوابت التعامل مع دالة الانتقال.

  • يوجد (exists)
    عرف يوجد: دالة (اسم_الملف: مؤشر[مصفوفة[مـحرف]]) => ثـنائي؛
    
    def exists: function(filename: ptr[array[Char]]) => Bool;
    
    تفحص وحود ملف أو مجلد معين.

  • اعد_التسمية (rename)
    عرف اعد_التسمية: دالة (الاسم_القديم: مؤشر[مصفوفة[مـحرف]]، الاسم_الجديد: مؤشر[مصفوفة[مـحرف]]) => صـحيح[32]؛
    
    def rename: @expname[rename] function (oldFilename: ptr[array[Char]], newFilename: ptr[array[Char]]) => Int[32];
    
    تعيد تسمية ملف أو مجلد.

  • امح (remove)
    عرف امح: دالة (اسم_الملف: مؤشر[مصفوفة[مـحرف]]) => ثـنائي؛
    
    def remove: @expname[remove] function (filename: ptr[array[Char]]) => Bool;
    
    تزيل ملفًا أو مجلدًا.

  • افتح_ملف (openFile)
    عرف افتح_ملف: دالة (اسم_الملف: مؤشر[مصفوفة[مـحرف]]، الوضع: مؤشر[مصفوفة[مـحرف]]) => مؤشر[مـلف]؛
    
    def openFile: @expname[fopen] function (filename: ptr[array[Char]], mode: ptr[array[Char]]) => ptr[File];
    
    مطابقة لدالة fopen من POSIX.

  • اغلق_ملف (closeFile)
    عرف اغلق_ملف: دالة (ملف: مؤشر[مـلف]) => صـحيح[32]؛
    
    def closeFile: @expname[fclose] function (file: ptr[File]) => Int[32];
    
    مطابقة لدالة fclose من POSIX.

  • اطبع (print)
    عرف اطبع: دالة (ملف: مؤشر[مـلف]، صيغة: مؤشر[مصفوفة[مـحرف]]، عناصر: ...أي) => صـحيح[32]؛
    
    def print: @expname[fprintf] function (file: ptr[File], format: ptr[array[Char]], args: ...any) => Int[32];
    
    مطابقة لدالة fprintf من POSIX.

  • امسح (scan)
    عرف امسح: دالة (ملف: مؤشر[مـلف]، صيغة: مؤشر[مصفوفة[مـحرف]]، عناصر: ...أي) => صـحيح[32]؛
    
    def scan: @expname[fscanf] function (file: ptr[File], format: ptr[array[Char]], args: ...any) => Int[32];
    
    مطابقة لدالة fscanf من POSIX.

  • اكتب (write)
    عرف اكتب: دالة (محتوى: مؤشر، حجم: صـحيح[32]، عدد: صـحيح[32]، ملف: مؤشر[مـلف]) => صـحيح[32]؛
    
    def write: @expname[fwrite] function (content: ptr, size: Int[32], count: Int[32], file: ptr[File]) => Int[32];
    
    مطابقة لدالة fwrite من POSIX.

  • اقرأ (read)
    عرف اقرأ: دالة (محتوى: مؤشر، حجم: صـحيح[32]، عدد: صـحيح[32]، ملف: مؤشر[مـلف]) => صـحيح[32]؛
    
    def read: @expname[fread] function (content: ptr, size: Int[32], count:Int[32], file: ptr[File]) => Int[32];
    
    مطابقة لدالة fread من POSIX.

  • اطلق (flush)
    عرف اطلق: دالة (ملف: مؤشر[مـلف]) => صـحيح[32]؛
    
    def flush: @expname[fflush] function (file: ptr[File]) => Int[32];
    
    مطابقة لدالة fflush من POSIX.

  • هات_الموقع (tell)
    عرف هات_الموقع: دالة (ملف: [مـلف]) => صـحيح[32]؛
    
    def tell: @expname[ftell] function (file: ptr[File]) => Int[32];
    
    مطابقة لدالة tell من POSIX.

  • انتقل (seek)
    عرف انتقل: دالة (ملف: مؤشر[مـلف]، ازاحة: صـحيح، موضع: صـحيح) => صـحيح[32]؛
    
    def seek: @expname[fseek] function (file: ptr[File], offset: Int, seek: Int) => Int[32];
    
    مطابقة لدالة tell من POSIX.

  • أنشئ_ملف (createFile)
    عرف أنشئ_ملف: دالة (اسم_الملف: مؤشر[مصفوفة[مـحرف]]، محتوى: مؤشر، حجم_المحتوى: صـحيح) => ثـنائي؛
    
    def createFile: function (filename: ptr[array[Char]], content: ptr, contentCount: Int) => Bool
    
    تنشئ ملفًا وتخزن فيه المحتوى المعطى.

  • اقرأ_ملف (readFile)
    عرف اقرأ_ملف: دالة (اسم_الملف: مؤشر[مصفوفة[مـحرف]]، النتيجة: مؤشر[مؤشر]، الحجم: مؤشر[صـحيح]) => ثـنائي؛
    
    def readFile: function (filename: ptr[array[Char]], result: ptr[ptr], size: ptr[Int]) => Bool
    
    تقرأ المحتوى الكامل لملف وترجعه.

  • انشئ_مجلد (makeDir)
    عرف انشئ_مجلد: دالة (اسم_المجلد: مؤشر[مصفوفة[مـحرف]]، الوضع: صـحيح) => ثـنائي؛
    
    def makeDir: function (directoryName: ptr[array[Char]], mode: Int) => Bool
    
    تنشئ مجلدًا جديدًا.

  • افتح_مجلد (openDir)
    عرف افتح_مجلد: دالة (اسم_المجلد: مؤشر[مصفوفة[مـحرف]]) => مؤشر[مـجلد]؛
    
    def openDir: @expname[opendir] function (directoryName: ptr[array[Char]]) => ptr[Dir];
    
    مطابقة لدالة opendir من POSIX.

  • اغلق_مجلد (closeDir)
    عرف اغلق_مجلد: دالة (مجلد: مؤشر[مـجلد]) => صـحيح[32]؛
    
    def closeDir: @expname[closedir] function (directory: ptr[Dir]) => Int[32];
    
    مطابقة لدالة closedir من POSIX.

  • صفر_مؤشر_مجلد (rewindDir)
    عرف صفر_مؤشر_مجلد: دالة (مجلد: مؤشر[مـجلد])؛
    
    def rewindDir: @expname[rewinddir] function (directory: ptr[Dir]);
    
    مطابقة لدالة rewinddir من POSIX.

  • اقرأ_مجلد (readDir)
    1: عرف اقرأ_مجلد: دالة (مجلد: مؤشر[مـجلد]) => مؤشر[قـيد_مجلد]؛
    2: عرف اقرأ_مجلد: دالة (اسم_المجلد: مؤشر[مصفوفة[مـحرف]]) => مؤشر[اسـماء_ملفات]؛
    
    1: def readDir: @expname[readdir] function (directory: ptr[Dir]) => ptr[DirEnt];
    2: def readDir: function (directoryName: ptr[array[Char]]) => ptr[FileNames];
    
    1: مطابقة لدالة readdir من POSIX.
    2: ترجع قائمة بأسماء الملفات في مجلد معين.

ريـاضيات (Math)

تحتوي وحدة `ريـاضيات` على الدالات التالية:
  • مطلق (abs)
      def abs: @expname[abs] function (n: Int[32]) => Int[32];
      def abs: @expname[llabs] function (n: Int[64]) => Int[64];
      def abs: @expname[fabsf] function (n: Float[32]) => Float[32];
      def abs: @expname[fabs] function (n: Float[64]) => Float[64];
      
    للحصول على القيمة المطلقة لرقم.

  • باقي (mod)
      def mod: @expname[fmodf] function (x: Float[32], y: Float[32]) => Float[32];
      def mod: @expname[fmod] function (x: Float[64], y: Float[64]) => Float[64];
      
    للحصول على باقي قسمة رقمين حقيقيين.

  • أس_طبيعي (exp)
      def exp: @expname[expf] function (x: Float[32]) => Float[32];
      def exp: @expname[exp] function (x: Float[64]) => Float[64];
      
    مطابقة لدالتي exp و expf من POSIX.

  • أس_طبيعي2 (exp2)
      def exp2: @expname[exp2f] function (x: Float[32]) => Float[32];
      def exp2: @expname[exp2] function (x: Float[64]) => Float[64];
      
    مطابقة لدالتي exp2 و exp2f من POSIX.

  • لو (log)
      def log: @expname[logf] function (x: Float[32]) => Float[32];
      def log: @expname[log] function (x: Float[64]) => Float[64];
      
    مطابقة لدالتي log و logf من POSIX.

  • لو2 (log2)
      def log2: @expname[log2f] function (x: Float[32]) => Float[32];
      def log2: @expname[log2] function (x: Float[64]) => Float[64];
      
    مطابقة لدالتي log2 و log2f من POSIX.

  • لو10 (log10)
      def log10: @expname[log10f] function (x: Float[32]) => Float[32];
      def log10: @expname[log10] function (x: Float[64]) => Float[64];
      
    مطابقة لدالتي log10 و log10f من POSIX.

  • جذر (sqrt)
      def sqrt: @expname[sqrtf] function (x: Float[32]) => Float[32];
      def sqrt: @expname[sqrt] function (x: Float[64]) => Float[64];
      
    مطابقة لدالتي sqrt و sqrtf من POSIX.

  • جذر3 (cbrt)
      def cbrt: @expname[cbrtf] function (x: Float[32]) => Float[32];
      def cbrt: @expname[cbrt] function (x: Float[64]) => Float[64];
      
    مطابقة لدالتي cbrt و cbrtf من POSIX.

  • أس (pow)
      def pow: @expname[powf] function (b: Float[32], e: Float[32]) => Float[32];
      def pow: @expname[pow] function (b: Float[64], e: Float[64]) => Float[64];
      
    مطابقة لدالتي pow و powf من POSIX.

  • جا (sin)
      def sin: @expname[sinf] function (x: Float[32]) => Float[32];
      def sin: @expname[sin] function (x: Float[64]) => Float[64];
      
    مطابقة لدالتي sin و sinf من POSIX.

  • جا_عكسي (asin)
      def asin: @expname[asinf] function (x: Float[32]) => Float[32];
      def asin: @expname[asin] function (x: Float[64]) => Float[64];
      
    مطابقة لدالتي asin و asinf من POSIX.

  • جا_زائدي (sinh)
      def sinh: @expname[sinhf] function (x: Float[32]) => Float[32];
      def sinh: @expname[sinh] function (x: Float[64]) => Float[64];
      
    مطابقة لدالتي sinh و sinhf من POSIX.

  • جا_زائدي_عكسي (asinh)
      def asinh: @expname[asinhf] function (x: Float[32]) => Float[32];
      def asinh: @expname[asinh] function (x: Float[64]) => Float[64];
      
    مطابقة لدالتي asinh و asinhf من POSIX.

  • جتا (cos)
      def cos: @expname[cosf] function (x: Float[32]) => Float[32];
      def cos: @expname[cos] function (x: Float[64]) => Float[64];
      
    مطابقة لدالتي cos و cosf من POSIX.

  • جتا_عكسي (acos)
      def acos: @expname[acosf] function (x: Float[32]) => Float[32];
      def acos: @expname[acos] function (x: Float[64]) => Float[64];
      
    مطابقة لدالتي acos و acosf من POSIX.

  • جتا_زائدي (cosh)
      def cosh: @expname[coshf] function (x: Float[32]) => Float[32];
      def cosh: @expname[cosh] function (x: Float[64]) => Float[64];
      
    مطابقة لدالتي cosh و coshf من POSIX.

  • جتا_زائجي_عكسي (acosh)
      def acosh: @expname[acoshf] function (x: Float[32]) => Float[32];
      def acosh: @expname[acosh] function (x: Float[64]) => Float[64];
      
    مطابقة لدالتي acosh و acoshf من POSIX.

  • ظل (tan)
      def tan: @expname[tanf] function (x: Float[32]) => Float[32];
      def tan: @expname[tan] function (x: Float[64]) => Float[64];
      
    مطابقة لدالتي tan و tanf من POSIX.

  • ظل_عكسي (atan)
      def atan: @expname[atanf] function (x: Float[32]) => Float[32];
      def atan: @expname[atan] function (x: Float[64]) => Float[64];
      
    مطابقة لدالتي atan و atanf من POSIX.

  • ظل_عكسي2 (atan2)
      def atan2: @expname[atan2f] function (y: Float[32], x: Float[32]) => Float[32];
      def atan2: @expname[atan2] function (y: Float[64], x: Float[64]) => Float[64];
      
    مطابقة لدالتي atan2 و atan2f من POSIX.

  • ظل_زائدي (tanh)
      def tanh: @expname[tanhf] function (x: Float[32]) => Float[32];
      def tanh: @expname[tanh] function (x: Float[64]) => Float[64];
      
    مطابقة لدالتي tanh و tanhf من POSIX.

  • ظل_زائدي_عكسي (atanh)
      def atanh: @expname[atanhf] function (x: Float[32]) => Float[32];
      def atanh: @expname[atanh] function (x: Float[64]) => Float[64];
      
    مطابقة لدالتي atanh و atanhf من POSIX.

  • سقف (ceil)
      def ceil: @expname[ceilf] function (x: Float[32]) => Float[32];
      def ceil: @expname[ceil] function (x: Float[64]) => Float[64];
      
    مطابقة لدالتي ceil و ceilf من POSIX.

  • جزء_صحيح (floor)
      def floor: @expname[floorf] function (x: Float[32]) => Float[32];
      def floor: @expname[floor] function (x: Float[64]) => Float[64];
      
    مطابقة لدالتي floor و floorf من POSIX.

  • تقريب (round)
      def round: @expname[roundf] function (x: Float[32]) => Float[32];
      def round: @expname[round] function (x: Float[64]) => Float[64];
      
    مطابقة لدالتي round و roundf من POSIX.

  • عشوائي (random)
      def random: @expname[rand] function () => Int;
      
    مطابقة لدالة rand من POSIX.

  • جهز_العشوائية (seedRandom)
      def seedRandom: @expname[srand] function (s: Word);
      
    مطابقة لدالة srand من POSIX.

شـبكة (Net)

تحتوي وحدة `شـبكة` على العناصر التالية:
  • هات (get)
    1: عرف هات: دالة (الرابط: مؤشر[مصفوفة[مـحرف]]، الناتج: مؤشر[مؤشر]، حجم_الناتج: مؤشر[صـحيح]) => ثـنائي؛
    2: عرف هات: دالة (الرابط: مؤشر[مصفوفة[مـحرف]]، اسم_الملف: مؤشر[مصفوفة[مـحرف]]) => ثـنائي؛
    
    1: def get: function (url: ptr[array[Char]], result: ptr[ptr], resultCount: ptr[Int]) => Bool;
    2: def get: function (url: ptr[array[Char]], filename: ptr[array[Char]]) => Bool;
    
    1: تجلب المورد المحدد بالرابط وترجعه.
    2: تجلب المورد المحدد بالرابط وتخزنه في الملف المحدد.

دليل مدير الحزم

مدير حزم الأسس (محا أو apm) ينزل الحزم مباشرة من موقع GitHub ويمكن استخدامه عبر سطر الأوامر أو من داخل البرنامج مباشرة.
للحصول على تعليمات استخدام مدير الحزم من سطر الأوامر اكتب الأمر التالي:
محا مساعدة
apm help
أما استخدام مدير الحزم من داخل البرنامج فيتم باستخدام دالة `اشمل_ملف` (importFile).
اشمل "مـحا.أسس"؛
مـحا.اشمل_ملف("<الناشر>/<اسم الحزمة>" [, "<اسم الملف>"])؛
import "Apm.alusus";
Apm.importFile("<author>/>pkg name>" [, "<filename>"]);

دليل مكتبة `ضـغط` (Zip)

تحتوي وحدة `ضـغط` على الدالات التالية:
  • استخرج_من_ملف (extractFromFile)
    عرف استخرج_من_ملف: دالة (
      اسم_الملف: مؤشر[مصفوفة[مـحرف]]، اسم_المجلد: مؤشر[مصفوفة[مـحرف]]،
      مستلم_الاشعارات: مؤشر[دالة (مؤشر[مصفوفة[مـحرف]]، مؤشر)]، معطيات: مؤشر
    ) => صـحيح؛
    
    def extractFromFile: function(
      filename: ptr[array[Char]], extractDirectory: ptr[array[Char]],
      callbackFunction: ptr[function (ptr[array[Char]], ptr)], arguments: ptr
    ) => Int;
    
    تستخرج ملفًا مضغوطا إلى المجلد المحدد.

  • اضغط_إلى_ملف (compressToFile؛)
    عرف اضغط_إلى_ملف: دالة (
      اسم_المف: مؤشر[مصفوفة[مـحرف]]، ملفات: مؤشر[مصفوفة[مؤشر[مصفوفة[مـحرف]]]]، عدد_الملفات: صـحيح،
      نوع_الاستخراج: مؤشر[مصفوفة[مـحرف]]
    ) => صـحيح؛
    
    def compressToFile: function(
      filename: ptr[array[Char]], files: ptr[array[ptr[array[Char]]]], filesCount: Int,
      extractType: ptr[array[Char]]
    ) => Int;
    
    تنشئ ملفًا مضغوطا يحتوي على الملفات المعطاة.

جميع الحقوق محفوظة لـ سرمد خالد عبداللّه 2019م \ 1440هـ.
نُشر هذا الملف برخصة الأسُس العامة (Alusus Public License)، الإصدار 1.0، والمضمّنة مع هذا الملف والمتوفرة أيضاً على الرابط https://alusus.org/alusus_license_1_0. يرجى قراءة الرخصة للتعرف على شروط الاستخدام والنسخ.