الترميز التكراري النموذجي
مثال على الترميز > استخدام لغة C للبرمجة

بعد ذلك يأتي استخدام الترميز النموذجي التكراري للغة السابقة بلغة البرمجة سي C. إذا تمت قراءة الترميز في الترميز الأصلي وينتج عنه رسالة خطأ. في حالة عدم تمكن الكود من الترميز يخرج في صمت إذا تم ترميز الكود بشكل صحيح.
لاحظ مدى التشابه الكبير بين الترميز الخطي في الأسفل مع القواعد النحوية في الأعلى. هناك إجراء لكل رمز غير خطي في القواعد. تترتب الرموز بطريقة الترتيب من أعلى لأسفل حتى تتم معالجة آخر رمز غير خطي. تعتمد أجزاء البرنامج على متغير عالمي هو sym، يحتوي على الجيل الثاني من رموز المدخلات ودالة getsym والتي تعمل على تحديث النظام عند استدعائها.
تم حذف تطبيقات دوال getsym والأخطاء للتبسيط
typedef enum {ident, number, lparen, rparen, times, slash, plus,
    minus, eql, neq, lss, leq, gtr, geq, callsym, beginsym, semicolon,
    endsym, ifsym, whilesym, becomes, thensym, dosym, constsym, comma,
    varsym, procsym, period, oddsym} Symbol;
 
Symbol sym;
void getsym(void);
void error(const char msg[]);
void expression(void);
 
int accept(Symbol s) {
    if (sym == s) {
        getsym();
        return 1;
    }
    return 0;
}
 
int expect(Symbol s) {
    if (accept(s))
        return 1;
    error("expect: unexpected symbol");
    return 0;
}
 
void factor(void) {
    if (accept(ident)) {
        ;
    } else if (accept(number)) {
        ;
    } else if (accept(lparen)) {
        expression();
        expect(rparen);
    } else {
        error("factor: syntax error");
        getsym();
    }
}
 
void term(void) {
    factor();
    while (sym == times || sym == slash) {
        getsym();
        factor();
    }
}
 
void expression(void) {
    if (sym == plus || sym == minus)
        getsym();
    term();
    while (sym == plus || sym == minus) {
        getsym();
        term();
    }
}
 
void condition(void) {
    if (accept(oddsym)) {
        expression();
    } else {
        expression();
        if (sym == eql || sym == neq || sym == lss || sym == leq || sym == gtr || sym == geq) {
            getsym();
            expression();
        } else {
            error("condition: invalid operator");
            getsym();
        }
    }
}
 
void statement(void) {
    if (accept(ident)) {
        expect(becomes);
        expression();
    } else if (accept(callsym)) {
        expect(ident);
    } else if (accept(beginsym)) {
        do {
            statement();
        } while (accept(semicolon));
        expect(endsym);
    } else if (accept(ifsym)) {
        condition();
        expect(thensym);
        statement();
    } else if (accept(whilesym)) {
        condition();
        expect(dosym);
        statement();
    }
}
 
void block(void) {
    if (accept(constsym)) {
        do {
            expect(ident);
            expect(eql);
            expect(number);
        } while (accept(comma));
        expect(semicolon);
    }
    if (accept(varsym)) {
        do {
            expect(ident);
        } while (accept(comma));
        expect(semicolon);
    }
    while (accept(procsym)) {
        expect(ident);
        expect(semicolon);
        block();
        expect(semicolon);
    }
    statement();
}
 
void program(void) {
    getsym();
    block();
    expect(period);
}
المثال الآخر عبارة عن ترميز شجرة بسيطة وفيها تستدعي وظيفة ترميز الشجرة نفسها لترتيب العقد
#include <stdio.h>
#include <stddef.h>
#include <stdlib.h>
 
\\ عقد الشجرة تحمل قيم صحيحة وعدادات لعقد أخرى في الشجرة
typedef struct tree_node {
        int value;
        struct tree_node *left, *right;
} tree_node_t;
 
\\وظيفة لإنشاء الشجرة لإتمام العملية، قم بتجاهلها
tree_node_t *make_tree(void);
\\وظيفة لترميز، الشجرة تقوم بترميز الشجرة باستدعاء نفسها
int         parse_tree(tree_node_t *root);
 
int main(void)
{
        tree_node_t *a_root = make_tree(); //make a simple tree.
        parse_tree(a_root);                          //parse the tree with parse_tree().
        return 0;
}
 
هذه الوظيفة ليست مهمة//
tree_node_t *make_tree(void) 
{
        tree_node_t *root = malloc(sizeof(struct tree_node));
        tree_node_t *branch1 = malloc(sizeof(struct tree_node));
        tree_node_t *branch2 = malloc(sizeof(struct tree_node));
        tree_node_t *leaf1 = malloc(sizeof(struct tree_node));
        tree_node_t *leaf2 = malloc(sizeof(struct tree_node));
        tree_node_t *leaf3 = malloc(sizeof(struct tree_node));
        tree_node_t *leaf4 = malloc(sizeof(struct tree_node));
        tree_node_t *subleaf = malloc(sizeof(struct tree_node));
 
        root->value = 0;
        branch1->value = 1;
        branch2->value = 2;
        leaf1->value = 3;
        leaf2->value =4;
        leaf3->value = 5;
        leaf4->value = 6;
        subleaf->value = 7;
 
        root->left = branch1;
        root->right = branch2;
        branch1->left = leaf1;
        branch1->right = leaf2;
        branch2->left = leaf3;
        branch2->right = leaf4;
        leaf1->left = NULL;
        leaf1->right = subleaf;
        leaf2->left = NULL;
        leaf2->right = NULL;
        subleaf->left = NULL;
        subleaf->right = NULL;
 
 
        return root;
}
 
int parse_tree(tree_node_t *root)
{
        printf("Current node value: %i\n", root->value); //تطبق قيمة العقدة node الحالية.
 
// راجع للتأكد من أن عدادات العقد عدادات فارغة.
        if(root->left && root->right) { 
                parse_tree(root->left);     //تنادي على نفسها، تمر من خلال العقدة (node) اليسرى من خلال.
                                                        // الجذر كجذر، محاكية الشجرة.
                parse_tree(root->right);  //كما بالأعلى.
        } else if(root->left) parse_tree(root->left); //إن كان هناك عقدة (node) واحدة فقط فارغة، رمّزها.
          else if(root->right) parse_tree(root->right);
          else return 0; //إن لم يكن هناك المزيد من العقد (nodes)، توقف.
}
يستخدم الكود السابق التكرار في استعراض شجرة البرنامج من أعلى لأسفل وطباعة القيم المرتبطة بالعقد وهذا مثال نموذجي على التكرار في البرمجة