الترميز التكراري النموذجي

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)، توقف.
}