icmun - En ligne dans le Cloud

PROGRAMME:

Nom

icmake - Un programme de maintenance (faire) utilitaire utilisant un C-comme la grammaire

SYNOPSIS

icmake [choix] source[.im] [dest[.bim]] [-- [arguments]]

icmun fichier bim

DESCRIPTION

Je fais(1) peut être utilisé comme alternative à faire(1). Dans son mode de fonctionnement standard, il
appelle les programmes suivants :

o icm-pp pour prétraiter le fichier icmake

o icm-comp pour compiler le byte-code icmake s

o icm-exécutable pour exécuter le fichier de byte-code

Je fais permet aux programmeurs d'utiliser un langage de programmation (ressemblant étroitement au célèbre
C-langage de programmation) pour définir les actions impliquées dans un programme (complexe)
maintenance. Pour ça, icmake propose divers opérateurs spéciaux ainsi qu'un ensemble de support
fonctions qui se sont avérées utiles pour la maintenance du programme.

Le programme icmun(1) peut être utilisé pour désassembler le fichier de byte-code (.bim) compilé. Icmun
est principalement utilisé pour l'illustration, l'éducation et le débogage.

Les make-utilities traditionnels recompilent les sources une fois que les fichiers d'en-tête sont modifiés. Dans le
contexte de C + + développement de programmes, c'est souvent une mauvaise idée, car ajouter un nouveau membre à un
class ne nécessite normalement pas que vous recompiliez les sources de la classe. Pour gérer la classe
dépendances icbuld(1) peut inspecter HORAIRE fichiers qui peuvent être utilisés pour définir les dépendances
parmi les classes. Par défaut, les dépendances de classe ne sont pas interprétées. Se référer au icmconf(7)
page de manuel pour plus de détails.

OPTIONS

Je fais utilise les fichiers et options suivants :

o la source: icmake fichier source du script (extension par défaut : .je suis).

o moins: binaire icmake fichier de script (par défaut : 'source'.bim, appelé le `fichier .bim'
ci-dessous).

o --: icmake séparateur d'arguments séparation icmake arguments à partir des arguments passés
au fichier .bimnl() args: arguments suivants -- sont passés au fichier .bim
en l'état et sont disponibles auprès du liste argv paramètre défini comme le icmake
des scripts principal deuxième paramètre de la fonction (voir ci-dessous à la section UTILISATEUR DÉFINI
FONCTIONS). Pour certaines options (voir ci-dessous), le -- le séparateur n'est pas requis.

Je fais prend en charge diverses options, décrites ci-après. Les -h l'option annule toutes les autres
options, le -a l'option annule toutes les autres options, à l'exception de -h. De l'action restante
choix (-b, -c, -e, -je, -p ainsi que -t) un seul peut être spécifié :

o -a
afficher des informations sur icmake, annulé par -h;

o -b
interrompu : utilisez l'option -e à la place ;

o -c
le icmake le fichier source est compilé, générant un fichier .bim ;

o -e
exécuter le icmake fichier .bim, donné comme icmakepremier argument de fichier de . Tout supplément
les arguments sont passés au fichier .bim tels quels, et -- ne doit pas être spécifié ;

o -F
les noms de fichiers et les drapeaux ainsi qu'un aperçu de toutes les actions à effectuer par
icmake sont affichés sur le flux de sortie standard ;

o -h
fournir des informations d'utilisation et terminer icmake;

o -i
le premier argument est le icmake fichier source, le fichier binaire par défaut est
construit si nécessaire. Tous les arguments supplémentaires sont transmis au fichier .bim
tel quel, et -- ne doit pas être spécifié ;

o -p
le icmake le fichier source est uniquement prétraité et le fichier prétraité est écrit
à icmakele deuxième argument de fichier (par défaut `source'.pim);

o -q
ignoré, sera supprimé à l'avenir icmake version;

o -t
l'argument suivant -t est le nom d'un fichier .bim temporaire, qui est supprimé
après icmakel'appel. Lorsque . est spécifié comme nom du fichier temporaire .bim
puis le répertoire temporaire par défaut, suivi de icmake's process-id, suivi de
.bim est utilisé.

Après le nom du fichier .bim temporaire, le nom du icmake script source
doit être spécifié. Tous les arguments supplémentaires sont transmis au fichier .bim tel quel, et
-- ne doit pas être spécifié ; Après avoir défini l'indicateur d'exécutable du fichier de script source
(chmod +x scénario), et en lui fournissant une ligne initiale comme celle-ci :

#!/usr/bin/icmake-t.

le icmake le script peut être appelé directement :

script arg1 arg2

auquel cas le icmake scénario 'scénario' est exécuté pendant qu'il reçoit le
arguments scénario argument1 argument2.

o -T
cette option doit être fournie avec le nom d'un répertoire qui est utilisé pour stocker
fichiers temporaires. Par exemple, lors de la compilation d'un icmake script, la sortie de icmake's
le préprocesseur est un fichier temporaire qui est supprimé à la sortie. Par défaut / Tmp est utilisé,
à moins que / Tmp n'est pas un répertoire accessible en écriture, auquel cas l'utilisateur actuel $ ACCUEIL
répertoire est utilisé. Les noms de fichiers temporaires implicites commencent toujours par l'ID de processus de
le courant icmake processus.

o -v
l’affichage icmakele numéro de version de , et fin icmake, annulé par -h

Icmun:

fichier bim: binaire icmake Fichier de script.

PRÉPROCESSEUR DIRECTIVES

Les directives de préprocesseur suivantes sont disponibles :

ou commenter :
Standard C commentaire (tous entre /* ainsi que */) ainsi que le commentaire de fin de ligne (tous
contenu de la ligne suivant //) sont ignorés.

o Démarrage du shell : La première ligne du icmake-script peut commencer par #!chemin, Où
chemin définit l'emplacement absolu du icmake programme. En faisant le script
exécutable, il peut être appelé sans appeler explicitement icmake.

Par exemple, si la première ligne d'un icmakefile (exécutable) 'icm' (sans extension)
contient

#!/usr/bin/icmake -i

puis icm peut être émis en tant que commande, exécutant ainsi

/usr/bin/icmake -i icm ...

Alternativement,

#!/usr/bin/icmake -t /tmp/icm

peut être utilisé, entraînant l'exécution de

#!/usr/bin/icmake -t /tmp/icm icm ...

Dans ce cas, le fichier binaire est supprimé à la sortie.

o #comprendre "nom de fichier"
Le fichier nom de fichier est inclus à l'emplacement de la directive

o #comprendre
Le fichier nom de fichier est inclus à l'emplacement du #comprendre directif; nom de fichier
est recherché dans les répertoires séparés par des deux-points spécifiés par le IM sûr, heureux et sain
variable. La première occurrence de nom de fichier dans les répertoires spécifiés par le IM
variable d'environnement est utilisée.

o #define identifiant [définition]
Le texte identifiant sera remplacé par définition. La définition peut contenir
références à des identifiants déjà définis, à l'aide des ${identifiant} format. Si la
${identifiant} n'a pas (encore) été défini, le texte ${identifiant} est littéralement conservé.
Pour éviter une récursivité infinie au maximum 100 ${identifiant} les remplacements sont autorisés.

Les définitions continuent à la ligne suivante si le dernier caractère d'une ligne est un
barre oblique inverse (\). (qui n'est pas inclus dans la définition). Le préprocesseur
concatène les chaînes à double guillemet, et les chaînes à double guillemet ne peuvent pas s'étendre sur plusieurs
lignes. Plusieurs blancs (en dehors des chaînes entre guillemets) dans les définitions sont
contracté à un seul espace vide.

La définition suivant le #définir l'identifiant est facultatif. S'il est omis, le
macro est définie, elle peut donc être utilisée dans #if(n)def directives (voir ci-dessous), mais elles
ne sont remplacés par aucun texte dans icmake instructions de code.

o #ifdef identifiant
Si la identifiant macro a été définie le prochain bloc de code (jusqu'à ce qu'une correspondance #else
or #endif directive a été lue) est compilé par octet. Sinon, le bloc de code est
ignoré.

o #ifndef identifiant
Si la identifiant la macro était ne sauraient défini le prochain bloc de code (jusqu'à ce qu'une correspondance
#else or #endif directive a été détectée) est compilé par octet. Sinon, le bloc de
le code est ignoré.

o #else
Met fin à un #ifdef ainsi que #ifndef directive, infirmant la décision d'acceptation concernant
le code suivant. Seulement un #else directive peut être associée à #if(n)def
directives.

o #endif
Termine le bloc de préprocesseur à partir de la correspondance #ifdef, #ifndef or #else
directif. Les #endif répertoire et sa correspondance #if(n)def directive doit être
spécifié dans le même fichier.

o #undef identifiant
Effacer identifiant à partir de l'ensemble des symboles définis. Cela n'affecte pas le
spécification de tout symbole précédemment défini dans lequel identifiant définition
a été utilisé. Si identifiant n'a pas été défini, un avertissement est émis.

DONNEES TYPES

Je fais prend en charge ces types de données :

o ASCII caractère des constantes
Les constantes de caractères ASCII se composent d'un caractère, entouré de caractères simples ou doubles
devis. Caractères uniques (par exemple, 'une') représentent le personnage lui-même. Standard
séquences d'échappement (par exemple, '\n') sont pris en charge et représentent leur standard converti
valeur (par exemple, '\n' représente la valeur ascii 10 (décimal)). Evasion non standard
séquences (par exemple, '\X') représentent le caractère ASCII suivant le caractère d'échappement
(alors '\X' équivaut à 'X'). Les séquences d'échappement composées de trois chiffres octaux représentent
le caractère ASCII correspondant à la valeur octale modulo 256 (par exemple, '\123').
Les séquences d'échappement constituées d'un x suivi de deux chiffres hexadécimaux représentent
le caractère ASCII correspondant à la valeur hexadécimale (par exemple, '\xa4').

o int
Les valeurs intégrales, allant de -0x8000 à travers 0x7fff. int les constantes peuvent être
spécifiés sous forme de nombres décimaux (commençant par les chiffres 1 à 9), nombres octaux
(commençant par 0, suivi d'un ou plusieurs chiffres octaux) nombres hexadécimaux
(commençant par 0x, suivi d'un ou plusieurs chiffres hexadécimaux) ou comme ASCII
constantes de caractères.

o un magnifique
Variables de texte. Les constantes de chaîne sont délimitées par des guillemets doubles. Chaîne multiple
les constantes peuvent être concaténées, mais une seule constante de chaîne ne peut pas s'étendre sur plusieurs
lignes. Constantes de chaîne séparées par des espaces blancs uniquement (c'est-à-dire des blancs, des sauts de ligne,
comment) sont concaténés et représentent une seule constante de chaîne. Pour indiquer un
fin de ligne dans une chaîne constante utiliser le \n séquence d'échappement.

Les constantes de caractères ASCII entourées de guillemets doubles peuvent également être utilisées dans
expressions arithmétiques si l'un des opérandes est un int. Le personnage unique
constante de chaîne must être une constante, et ne peut pas être une un magnifique variable.

De même, les constantes de caractères ASCII entourées de guillemets simples peuvent être utilisées dans
situations où un opérande de chaîne est attendu.

o liste
Une structure de données contenant une série de données accessibles individuellement un magnifique valeurs. Quand
une liste contient des éléments, son premier élément est indiqué par l'index 0.

o annuler
Utilisé avec les définitions de fonction pour indiquer que la fonction ne renvoie pas de
valeur.

Les variables peuvent être définies au niveau global ainsi qu'à n'importe quel niveau local à l'intérieur
les fonctions. Lorsqu'il est défini à l'intérieur des fonctions, le standard C règles de portée et de visibilité
appliquer. Par exemple, les variables locales ne peuvent être utilisées que seules ou dans des
blocs, leur visibilité est masquée dans des blocs plus profondément imbriqués en définissant un
variable nommée à l'intérieur de ces blocs plus profondément imbriqués. Les variables sont fortement typées, et
ne peut pas avoir de type annuler.

Les variables peuvent être initialisées lorsqu'elles sont définies. Les initialisations sont des expressions qui
peut utiliser des fonctions prédéfinies ou définies par l'utilisateur, des valeurs constantes et des valeurs de variables qui sont
visible au point de définition.

PRÉDÉFINI CONSTANTES

Les constantes suivantes sont prédéfinies par icmake. Tous sont constants int valeurs:

─────────────────────────────────
valeur de symbole destinée à
─────────────────────────────────
Liste de marques O_ALL 8
Liste de marques O_DIR 2
O_FILE 1 liste de marques
Liste de marques O_SUBDIR 4
─────────────────────────────────
OFF 0 écho
ON 1 écho
─────────────────────────────────
P_CHECK 0 appels système
P_NOCHECK 1 appels système
─────────────────────────────────
S_IEXEC 32 statistiques
S_IFCHR 1 statistique
Statistiques S_IFDIR 2
Statistiques S_IFREG 4
Statistiques S_IREAD 8
S_IWRITE 16 statistiques
─────────────────────────────────

Les constantes suivantes dépendent de l'architecture :

?? ??
symbole 1 lorsqu'il est défini sur la plate-forme, sinon 0
?? ??
unix Unix, généralement avec le compilateur gcc de GNU
UNIX peut également être disponible
linux x86 sous Linux (généralement avec gcc)
LINUX peut également être disponible
M_SYSV, M_UNIX x86 exécutant SCO/Unix
_POSIX _SOURCE Unix avec compilateur compatible Posix
__hpux HP-UX, avec le compilateur HP natif
?? ??

LES OPÉRATEURS

de type int opérande(s) :

Tous C sont disponibles (à l'exception des opérateurs pointeurs, comme icmake ne supporte pas
pointeurs). Ils fonctionnent comme leur C-homologues en langage de programmation.

chaîne de caractères opérande(s) :

Pour un magnifique de type variables et/ou constantes les opérateurs suivants sont disponibles (a ainsi que b
représentent un magnifique variables ou constantes):

o a + b: renvoie un nouveau un magnifique valeur contenant la concaténation de un magnifique valeurs a
ainsi que b. Noter que un magnifique les constantes peuvent être directement concaténées (sans utiliser le +
opérateur), par exemple, les deux lignes suivantes définissent toutes les deux la chaîne "Bonjour monde":

"Bonjour le monde"
"bonjour" + "monde"

o a += b: a Doit être un un magnifique variable, à laquelle le un magnifique variable ou valeur b is
ajouté

o comparaisons de chaînes : opérateurs == != <= >= < > != ainsi que == peut être appliqué à un magnifique
valeurs ou variables, renvoyant 1 si la comparaison réussit, sinon 0.
La comparaison est sensible à la casse et suit l'ordre ou les caractères tels que définis
dans l' ASCII jeu de caractères.

o !a: le booléen ! (not) l'opérateur renvoie 1 si le un magnifique a est vide, sinon 0 est
revenu.

o a plus jeune b, a Plus récent b: renvoie 1 si fichier a est plus récent que le fichier b. Par exemple,
"source.cc" Plus récent "source.o". Les fichiers a ainsi que b ne doivent pas exister : si les deux n'existent pas
existe 0 est renvoyé ; si b n'existe pas, 1 est renvoyé ; si a n'existe pas 0 est
revenu; s'ils sont également anciens, 0 est renvoyé. (les existe() fonction prédéfinie
(voir ci-dessous, rubrique PRÉDÉFINI FONCTIONS) peut être utilisé pour tester explicitement si un
le fichier existe).

o a plus b: tourne 1 si fichier a est plus ancien que le fichier b. Par exemple, "libprog.a" plus
"source.o". Les fichiers a ainsi que b ne doivent pas exister : si les deux n'existent pas, 0 est
revenu; si a n'existe pas, 1 est renvoyé ; si b n'existe pas 0 est renvoyé ; si
ils sont également anciens 0 est retourné.

o []: l'opérateur index récupère un caractère à partir d'une variable chaîne ou d'une constante : il
renvoie une chaîne en tant que rvaleur. Par conséquent, l'instruction suivante compile OK :

// suppose que str1 et str2 sont des chaînes
str1 = str2[3] ;

mais l'instruction suivante ne compilera pas :

str2[3] = "un" ;

Une chaîne vide est renvoyée si une valeur d'index non valide est fournie.

o L'opérateur `backtick` (`chaîne cmd`)
Une chaîne placée entre deux backticks est exécutée par le pope(3) fonction. Les
la sortie standard générée par la commande stockée dans l'argument de chaîne est
renvoyé sous forme de liste. Une liste vide indique que la commande n'a pas pu être exécutée.
Une commande qui a pu être exécutée mais n'a produit aucune sortie renvoie une liste
contenant un élément vide. La sortie du flux d'erreur standard de la commande n'est pas
collectées par l'opérateur backtick. Cependant, la redirection de shell standard pourrait être
utilisé pour collecter la sortie du flux d'erreur standard. Exemple:

printf(`"ls"`); // imprime les éléments dans
// le répertoire courant

La fonction prédéfinie eval(chaîne cmd) se comporte exactement comme le backtick
opérateur : ce sont des synonymes.

de type liste opérande(s) :

Pour liste variables de type et/ou valeurs les opérateurs suivants sont disponibles :

o a + b: renvoie un nouveau liste valeur contenant la concaténation de liste valeurs a ainsi que
b. C'est ne sauraient une opération ensembliste : si un élément apparaît à la fois dans a et en b, ils vont
apparaissent deux fois dans la liste résultante (l'ajout d'ensemble est fourni par le
fonction liste union).

o a - b: renvoie un nouveau liste valeur contenant les éléments dans a qui ne sont pas présents
in b. Ce is une opération set-difference : la liste renvoyée contient tous les éléments
in a qui ne sont pas des éléments de b.

o a += b: éléments dans b sont ajoutés aux éléments de a, qui doit être un liste
variable. C'est ne sauraient une opération définie.

o a -= b: éléments dans b sont retirés des éléments dans a, qui doit être un liste
variable. Ce is une opération ensembliste : tous les éléments de a qui se trouvent dans b
retiré de a.

o liste des comparaisons d'égalité : opérateurs != ainsi que == peut être appliqué à liste valeurs ou
variables. Opérateur == renvoie 1 si les deux listes ont élément par élément identiques
éléments, sinon 0 est renvoyé. Opérateur != inverse le résultat de ==.

o !a: le booléen ! l'opérateur renvoie 1 si le liste a est vide, sinon 0 est
revenu.

o []: l'opérateur index récupère un élément de liste à partir d'une variable de liste : il renvoie un
chaîne en tant que rvaleur. Par conséquent, l'instruction suivante compile OK :

// suppose que lst est une liste, str est une chaîne
str = lst[3] ;

mais l'instruction suivante ne compilera pas :

lst[3] = chaîne ;

Une chaîne vide est renvoyée si une valeur d'index non valide est fournie.

Moulage:

Les moulages de type peuvent être effectués en utilisant la norme C cast-operator pour lancer :

o Chaînes en ints et vice versa ((entier)"123", (chaîne)55)

o Chaînes de listes (liste LST = (liste)"bonjour")

ÉCOULEMENT CONTRÔLE

Je fais propose le sous-ensemble suivant de Cles déclarations de. Ils peuvent être utilisés comme dans le C
langage de programmation.

o expression ;
La déclaration d'expression simple ;

o L'énoncé composé
Les variables de n'importe quel type peuvent être définies et initialisées n'importe où à l'intérieur de n'importe quel composé
déclaration. le définition d'une variable commence à son point de définition.

o if (état) déclaration
A l'intérieur de la condition, une variable peut être définie et initialisée. Par exemple,

if (chaîne str = getText())
processus(str);

Dans cet exemple, processus n'est pas appelé si getText () renvoie une chaîne vide. Les
variable str n'existe ni avant ni après la if déclaration.

o if (état) déclaration d'autre déclaration
Comme pour l'instruction précédente, à l'intérieur de la condition, une variable peut être définie et
initialisé.

o en (initial; état; incrément) déclaration
Les variables (d'un même type) peuvent être initialisées (et éventuellement définies) dans le
init section. le init, condition ainsi que incrément les sections peuvent rester vides. Les
la section de condition vide est interprétée comme `toujours oui".

o tout en (état) déclaration
A l'intérieur de la condition, une variable peut être définie et initialisée.
Un complément do while () la déclaration n'est pas disponible. Notez que définir un
variable, l'utilisation d'une expression d'initialisation signifie que l'initialisation
l'expression est exécutée à chaque itération de la tout en déclaration. Alors ce qui suit
L'instruction ne se terminera jamais et affichera un flux sans fin de valeurs 10 :

tandis que (entier x = 10)
printf(x--, "\n");

o retour;et retourner expression;
Plaine retourner les déclarations peuvent être utilisées dans annuler fonctions, et retourner expression
les instructions sont utilisées dans d'autres types de fonctions. La fonction principal a un type de retour
annuler et ainsi dans principal simple retourner les déclarations peuvent être utilisées. Par défaut un icmake
la valeur de sortie du script est égale à 0. Utilisez la fonction intégrée sortie (voir ci-dessous) à préciser
toute autre valeur de sortie.

Be informé: le comportement des fonctions non vides ne renvoyant pas de valeurs est indéfini.

o pause
Feuilles en ainsi que tout en instructions, annulant la condition de l'instruction.

o continuer
Continue avec l'itération suivante d'un en or tout en déclaration.

o sortie(expression)
Met fin à l'exécution d'un icmake-scénario. Les expression doit évaluer à un int
value, qui devient la valeur de sortie du script.

PRÉDÉFINI FONCTIONS

Je fais offre les fonctions prédéfinies suivantes, qui peuvent être utilisées n'importe où dans icmake
scripts. L'aperçu suivant est classé par ordre alphabétique par nom de fonction.

o annuler arghead(chaîne h)
Fonction d'assistance de exécutable() (voir aussi ci-dessous à exécutable()): définit la `tête d'argument',
pour être utilisé avec exécutable(). Par défaut, l'"argument head" est une chaîne vide.

o annuler queue de poule (chaîne de caractères t)
Fonction d'assistance de exécutable() (voir aussi ci-dessous à exécutable()): définit la `queue d'argument',
pour être utilisé avec exécutable(). Par défaut, la « queue d'argument » est une chaîne vide.

o int ascii(chaîne s)
Renvoie le premier caractère de s en tant qu'entier ; par exemple, ascii("A") renvoie 65 ;

o un magnifique ascii(entier i)
Retours i comme une chaîne, par exemple, ascii(65) renvoie la chaîne "Un";

o un magnifique change_base(chaîne fichier, un magnifique nouvelle base)
Modifie le nom de base de filet, renvoie le nom modifié. Par exemple,
change_base("/chemin/demo.im", "dehors") Retours "/chemin/sortie.im";

o un magnifique change_ext(chaîne fichier, un magnifique nouveau suivant)
Modifie l'extension de filet, renvoie le nom modifié. Par exemple,
rss_changeExt("source.cc", "o") Retours "source.o";

o un magnifique change_path(chaîne fichier, un magnifique nouveau chemin)
Modifie la spécification du chemin de filet, renvoie le nom modifié. Par exemple,
change_path("tmp/binaire", "/ usr / bin") Retours "/usr/bin/binaire". Notez que le
/-séparateur est inséré si nécessaire.

o un magnifique chdir(chaîne nouveau répertoire)
Modifie le répertoire de travail du script, renvoie le répertoire précédent en tant qu'absolu
chemin.

Utilisez chdir(".") pour obtenir le répertoire de travail courant, chdir("") peut être utilisé pour
obtenir le répertoire de travail de démarrage (cette fonctionnalité a été interrompue dans les versions
avant 7.00hXNUMX, mais est maintenant opérationnel). La fonction termine le
icmake-script si le spécifié nouveaurép n'existe pas.

o un magnifique chdir(entier vérification, un magnifique nouveau répertoire)
Même fonctionnalité que la fonction précédente, mais en spécifiant vérification as
P_NOCHECK. la fonction ne terminera pas le script. Au contraire, il renverra le
répertoire de travail actuel du script.

o cmdhead(chaîne h)
Fonction d'assistance de exécutable() (voir aussi ci-dessous à exécutable()) : Définit une `tête de commande', pour
être utilisé avec exécutable(). Par défaut, la "tête de commande" est une chaîne vide.

o cmdtail(chaîne t)
Fonction d'assistance de exécutable() (voir aussi ci-dessous à exécutable()) : Définit une « queue de commande », pour
être utilisé avec exécutable(). Par défaut, la « queue de commande » est une chaîne vide.

o écho (entier opter)
Contrôle l'écho des programmes appelés (et leurs arguments), spécifiez de remise si écho
n'est pas demandé. Par défaut écho (ACTIVÉ) est utilisé.

o un magnifique élément(int indice, liste (ou chaîne) var)
Agit de manière identique à l'opérateur index : se référer à l'index ([]) opérateur dans le
LES OPÉRATEURS.

o liste eval(chaîne chaîne)
Cette fonction agit de manière identique à l'opérateur backtick. L'exemple fourni avec
l'opérateur backtick aurait donc aussi pu s'écrire ainsi :

printf(eval("ls")); // imprime les éléments dans le courant
// répertoire

o exec(chaîne cmd, ...)
Exécute la commande avec des arguments. Chaque argument sera préfixé par tête d'argument()'s
argument et postfixé par queue d'arg()l'argumentation. Notez qu'aucun espace n'est inséré
jusqu'à XNUMX fois tête d'argument()le contenu de , l'argument proprement dit et queue d'arg()l'argumentation. Tous
ainsi les arguments modifiés sont concaténés, cette fois séparés par des blancs simples, et
puis tête de commande()le contenu de est inséré entre la commande et le premier argument
(de part et d'autre délimité par des blancs simples) et cmdtail()le contenu de est ajouté
aux arguments (là encore, séparés par un seul blanc). PATH est recherché pour localiser
cmd. 0 est renvoyé.

o exec(entier checkcmd, un magnifique cmd, ...)
Même fonctionnalité que la fonction précédente, mais en spécifiant vérification as
NOT_CHECKED la fonction ne terminera pas le script. Au contraire, il renverra le
l'état de sortie de la commande appelée, ou 0x7f00 si la commande n'a pas été trouvée.

o exécuter(chaîne cmd, un magnifique cmdhd, un magnifique Arghd, ..., un magnifique argument, un magnifique cmdtl)
Pareil que exécutable(), mais la commande head/tail et l'argument head/tail doivent être spécifiés.

La commande réellement exécutée commence par cmd, Suivie par cmdhd. Vient ensuite une série
d'arguments suit, chacun entouré par Arghd ainsi que argument. La commande se termine par
cmdtl. 0 est retourné

o exécuter(int vérification, un magnifique cmd, un magnifique cmdhd, un magnifique Arghd, ..., un magnifique argument,
un magnifique cmdtl)
Même fonctionnalité que la fonction précédente, mais en spécifiant vérification as
NOT_CHECKED la fonction ne terminera pas le script. Au contraire, il renverra le
l'état de sortie de la commande appelée, ou 0x7f00 si la commande n'a pas été trouvée.

o int existe(chaîne fichier)
Renvoie une valeur non nulle si filet existe, sinon 0 est renvoyé.

o liste fgets(chaîne fichier, liste décalage)
REMARQUE: in icmake version 8.00.00 le prototype de cette fonction a été modifié de
liste fgets(chaîne fichier, int décalage) à liste fgets(chaîne fichier, liste décalage).

La ligne suivante trouvée au décalage contenu dans compenser est lu à partir de filet. Passer un
liste vide à fgets lire filet depuis son commencement.

Il renvoie une liste contenant comme premier élément le contenu de la ligne lue
(sans le \n fin de ligne), comme deuxième élément, la fin de ligne `\n»
(si rencontré), et comme troisième élément la chaîne OK si une ligne a été réussie
lire, FAIL si la lecture du fichier a échoué. Lors de la lecture à l'EOF, une liste vide est
revenu. La liste renvoyée peut contenir des éléments supplémentaires, qui sont internes
utilisé par fgets lors de la lecture de la ligne suivante.

Pour lire plusieurs lignes, commencez par passer une liste vide comme obtient deuxième argument.
Pour lire les lignes suivantes, transmettez la liste précédemment renvoyée à fgets seconde
argument.

Voici un exemple montrant comment lire un fichier complet :

liste ret;
while (1)
{
ret = fgets("nom de fichier", ret);
si (!ret)
break;
processus(ret[0], ret[1]);
}

o int fprintf(chaîne nom de fichier, ...)
Ajoute tous les arguments (séparés par des virgules) au fichier nom de fichier. Renvoie le nombre de
arguments imprimés.

o int fprintf(chaîne nom de fichier, un magnifique le format, ...)
Ajoute tous les arguments (séparés par des virgules) au fichier nom de fichier. Renvoie le nombre de
arguments imprimés.

If le format contient des espaces réservés %1 .. %n la sortie est formatée (voir aussi
format str). Notez que dans ce cas, le comptage des arguments commence (également) au-delà de la
chaîne de format : le premier argument suivant le format est dénommé %1.

o un magnifique get_base(chaîne fichier)
Renvoie le nom de base de filet. Le nom de base est le fichier sans son préfixe de chemin
et sans son extension. L'extension est toutes les informations à partir de la dernière
point dans le nom du fichier. Si aucun point final n'est trouvé, le nom du fichier est le nom de base.
Par exemple, le nom de base de un B équivaut à a, le nom de base de abc équivaut à un B, la base
nom de abc équivaut à c.

o un magnifique obtenir ()
Renvoie la prochaine touche enfoncée sous forme de chaîne (il n'est pas nécessaire d'appuyer sur « Entrée »).

o un magnifique get_dextr(chaîne fichier)
Renvoie l'extension de filet, y compris le point de séparation. L'extension est tout
informations commençant au dernier point du nom de fichier.

Si aucun point final n'est trouvé, une chaîne vide est renvoyée.

o liste getenv(chaîne envvar)
Renvoie la valeur de la variable d'environnement envvar dans une liste contenant deux éléments :

le premier élément indique si la variable d'environnement a été définie (valeur
"1") ou non (valeur "0");
le deuxième élément indique la valeur de la variable d'environnement.

Les variables d'environnement sont de la forme variable=valeur, et si défini la liste
le deuxième élément contient Plus-value. Si la valeur est vide, la variable est définie, mais
n'a aucun texte associé.

o un magnifique get_ext(chaîne fichier)
Renvoie l'extension de filet, à l'exception du point de séparation. L'extension est tout
informations commençant au dernier point du nom de fichier.

Si aucun point final n'est trouvé, une chaîne vide est renvoyée.

o int getpid()
Renvoie le process-id de l'interpréteur de byte code icmake icm-exécutable.

o un magnifique obtient ()
Renvoie la ligne suivante lue au clavier sous forme de un magnifique. La ligne inscrite sur le
clavier doit se terminer par une touche 'Entrée', qui n'est pas stockée dans le retour
chaîne.

o un magnifique get_path(chaîne fichier)
Renvoie le préfixe du chemin de filet. Le préfixe du chemin est toutes les informations jusqu'à (et
y compris) le séparateur de répertoire final (qui est, selon le
système, une barre oblique inverse ou une barre oblique inverse).

Si aucun chemin n'est trouvé, une chaîne vide est renvoyée.

o int listfind(liste la première, un magnifique chaîne)
Renvoie le premier index dans LST où la chaîne str est trouvé, ou -1 si LST ne collecte
contiennent str.

o int écouter(liste l)
Renvoie le nombre d'éléments dans liste.

o liste listunion(liste lhs, liste droite)
Renvoie une liste contenant l'union des éléments dans lhs ainsi que rhs.

o liste listunion(liste la première, un magnifique chaîne)
Renvoie une liste contenant l'union des éléments dans LST ainsi que str.

o liste makelist(chaîne masque)
Renvoie une liste de tous les fichiers correspondants masque. Par exemple, makelist("*.c") renvoie une liste
contenant tous les fichiers se terminant par .c.

o liste liste de création(type, un magnifique masque)
Identique à la fonction précédente, mais le type des éléments du répertoire peut être
spécifié comme premier argument :

signification du symbole
IS_ALL obtient toutes les entrées du répertoire
IS_DIR obtient tous les répertoires, y compris . et ..
IS_FILE obtenir une liste de fichiers
IS_SUBDIR obtient tous les sous-répertoires

Notez que le modèle * ne correspondra pas aux entrées cachées sous un fonctionnement de type Unix
systèmes. Utilisation .* pour ça.

o liste makelist(chaîne masque, plus récent, un magnifique fichier de comparaison)
Renvoie la liste de tous les fichiers correspondant au masque qui sont plus récents que ceux fournis
fichier de comparaison. Opérateur plus jeune peut être utilisé à la place de Plus récent. Noter que Plus récent ainsi que
plus jeune sont des opérateurs, pas des chaînes.

o liste makelist([int = IS_FILE,] un magnifique masque, plus récent, un magnifique fichier de comparaison)
Identique à la fonction précédente, mais type peut être spécifié comme dans liste liste de création(type,
un magnifique masque).

o makelist(chaîne masque, plus âgée, un magnifique fichier de comparaison)
Voir au dessus; renvoie une liste de fichiers plus anciens que le fichier de comparaison.

o liste de création(type, un magnifique masque, plus âgée, un magnifique fichier de comparaison)
Identique à la fonction précédente, mais type peut être spécifié comme dans liste liste de création(type,
un magnifique masque).

o int imprimerf(...)
Affiche tous les arguments (séparés par des virgules) à l'écran (c'est-à-dire le flux de sortie standard).
Renvoie le nombre d'arguments imprimés.

o int printf(chaîne le format, ...)
Affiche tous les arguments (séparés par des virgules) à l'écran (c'est-à-dire le flux de sortie standard).
Renvoie le nombre d'arguments imprimés (le le format chaîne compte comme un argument).

If le format contient des espaces réservés %1 .. %n la sortie est formatée (voir aussi
format str).

o int putenv(chaîne envvar)
Ajoute envvar au courant (icmake) environnement Utilisez le format : "VAR=valeur".
Retours 0.

o un magnifique redimensionner(chaîne str, int nouvelle longueur) Renvoie une copie de la chaîne str, redimensionné à
nouvelle longueur personnages. Si nouvelle longueur est négatif, une chaîne vide est renvoyée,
if nouvelle longueur dépasse str longueur, puis les caractères nouvellement ajoutés sont initialisés
aux espaces vides.

o int taillede(liste l)
Obsolète : utilisation écouter.

o int sizeoflist(liste l)
Obsolète : utilisation écouter.

o liste stat(chaîne entrée)
Retours état(2) informations d'entrée de répertoire entrée sous forme de liste. La liste retournée
a deux éléments : l'élément 0 est le attribuer Plus-value, l'élément 1 contient la taille de
le fichier.

Les attributs sont renvoyés sous forme d'indicateurs binaires, composés des éléments prédéfinis suivants
constantes :

S_IFCHR S_IFDIR S_IFREG
S_IREAD S_IWRITE S_IEXEC

Voir le état(2) page de manuel pour la signification de ces constantes.

o liste stat (vérification, un magnifique entrée)
Identique à la fonction précédente, mais en spécifiant vérification as P_NOCHECK la fonction
ne terminera pas le script. Au contraire, il retourne étatla valeur de retour de (2).

o int strchr(chaîne str, un magnifique caractères)
Renvoie le premier index dans str où l'un des caractères de caractères est trouvé, ou -1
if str ne contient aucun des caractères de caractères.

o int strlen(chaîne chaîne)
Renvoie le nombre de caractères dans str (sans compter le 0 final).

o int strfind(chaîne meule de foin, un magnifique aiguille)
Indice de retour dans meule de foin De aiguille est trouvé, ou -1 si aiguille n'est pas contenu
in meule de foin.
Ce fonction était appelé strstr() in versions before 7.00.

o int strformat(chaîne format,...)
Renvoie une chaîne formatée en utilisant les espaces réservés %1 .. %2 pour adresser les arguments
format suivant.
Mise en situation :

void principal ()
{
int i = 10;
entier j = 20;
chaîne s1;
chaîne s2;
// approche traditionnelle:
s1 = (chaîne)i + " " + (chaîne)j + " " + (chaîne)i ;
// en utilisant strformat :
s2 = strformat("%1 %2 %1", i, j);
printf("s1 = %1, s2 = %2\n", s1, s2) ;
}

o un magnifique strlwr(chaîne s)
Renvoie un doublon en minuscules de s.

o liste strtok(chaîne str, un magnifique séparateurs)
Renvoie une liste contenant toutes les sous-chaînes de str séparés par un ou plusieurs
caractères (consécutifs) dans séparateurs. Par exemple, strtok("Bonjour icmake's+world", " +")
renvoie la liste contenant les trois chaînes "Bonjour", "icmake's"et "monde".

o un magnifique strupr(chaîne s)
Renvoie un doublon en majuscule de s.

o un magnifique substr(chaîne texte, int décalage, int compter)
Renvoie une sous-chaîne de texte, À partir de compenser, Consistant en compter personnages. Si
compenser dépasse (ou égale) la taille de la chaîne ou si compter <= 0, puis une chaîne vide
est retourné. Si compenser est inférieur à 0, alors 0 est utilisé.

o int system(chaîne commande)
Exécute commander. La valeur de retour indique la valeur de sortie de la commande exécutée. Les
un magnifique commander peut contenir des caractères de redirection et/ou de canalisation.

o int système(int vérification, un magnifique commande)
Même fonctionnalité que la fonction précédente, mais en spécifiant vérification as
NOT_CHECKED la fonction ne terminera pas le script. Au contraire, il renverra le
l'état de sortie de la commande appelée, ou 0x7f00 si la commande n'a pas été trouvée.

o un magnifique trim(chaîne s)
Renvoie une copie de s sans espaces blancs de début et de fin.

o un magnifique trimleft(chaîne chaîne)
Renvoie une copie de s sans espaces blancs en tête.

o un magnifique trim(chaîne s)
Renvoie une copie de s sans espaces blancs à la fin.

UTILISATEUR DÉFINI FONCTIONS

annuler principal

Je fais les scripts doivent être fournis avec une fonction définie par l'utilisateur principal. La fonction principal a
trois paramètres facultatifs, qui peuvent être omis du dernier (envp) au premier
(argc), comme dans C. Son prototype complet est (remarque : annuler type de retour) :

void main(int argc, liste argv, liste envp)

In principale(),

o argc représente le nombre d'éléments dans argv;

o argv contient les arguments, l'élément 0 étant égal au nom du .bim
fichier;

o envp contient les variables « d'environnement ». La fonction écouter peut être utilisé pour
déterminer le nombre de ses éléments. Éléments dans envp avoir la forme
variable=valeur. Alternativement, la fonction obtenir peut être utilisé pour récupérer un
variable d'environnement spécifique immédiatement. Exemple:

void main(int argc, liste argv)
{
liste àCompiler ;
int idx ;

si (argc == 1)
utilisation(élément(0, argv));

if (toCompile = altéré("*.cc"))
{
pour (idx = longueur(toCompile); idx--; )
compile(element(idx, toCompile));

if (getenv("dryrun")[0] == "0")
lien (élément (2, argv));
}
}

Après avoir initialisé toutes les variables globales dans l'ordre de leurs définitions principal est appelé par
icmakesystème de support d'exécution de pour effectuer des tâches supplémentaires.

En outre défini utilisateur fonctions

Des fonctions supplémentaires peuvent être définies. Une fois définies, ces fonctions peuvent être appelées. Effronté
le référencement de variables ou de fonctions n'est pas pris en charge, mais l'appel récursif
les fonctions est. Comme les déclarations de fonction ne sont pas prises en charge, la récursivité indirecte n'est pas
pris en charge non plus.

Les fonctions définies par l'utilisateur doivent avoir les éléments suivants :

o Le type de retour de la fonction, qui doit être l'un des annuler, entier, un magnifique or liste. Il
n'est pas un type par défaut.

o Le nom de la fonction, par exemple, compiler.

o Une liste de paramètres, définissant zéro ou plusieurs paramètres séparés par des virgules. Les paramètres
se composent d'un nom de type (entier, un magnifiqueou liste) suivi du
identifiant du paramètre. Par exemple, (chaîne de caractères fichier de sortie, un magnifique la source).

o Un corps entouré d'une paire d'accolades ({ ainsi que }).

Les corps de fonction peuvent contenir des définitions de variables (éventuellement initialisées). Variable
les définitions commencent par un nom de type, suivi d'une ou plusieurs virgules séparées (éventuellement
initialisé) identificateurs de variables. Si une variable n'est pas explicitement initialisée, elle est
initialisé par défaut. Par défaut un int variable est initialisée à 0, un un magnifique is
initialisé à une chaîne vide ("") Et un liste est initialisé à une liste de zéro éléments.

En plus des définitions de variables, les corps peuvent contenir zéro ou plusieurs instructions (cf.
ÉCOULEMENT CONTRÔLE). Notez que des variables peuvent être définies (et éventuellement initialisées)
n'importe où à l'intérieur des fonctions, et aussi dans si, en ainsi que tout en Déclarations.

Le comportement de icmake-les scripts utilisant des fonctions non vides qui ne renvoient pas de valeurs ne sont pas
Défini.

Utiliser icmun en ligne en utilisant les services onworks.net