icmake: en línea en la nube

PROGRAMA:

NOMBRE

icmake - Un programa de mantenimiento (para lograr) utilidad usando un C-como gramática

SINOPSIS

icmake [opciones] fuente [.im] [dest [.bim]] [- [argumentos]]

icmun archivo bim

DESCRIPCIÓN

Yo hago(1) se puede utilizar como alternativa a para lograr(1). En su modo de funcionamiento estándar,
llama a los siguientes programas:

o icm-pp para preprocesar el archivo icmake

o comp-icm para compilar el código de bytes icmake s

o icm-ejecutivo para ejecutar el archivo de código byte

Yo hago permite a los programadores utilizar un lenguaje de programación (muy parecido al conocido
C-lenguaje de programación) para definir las acciones que están involucradas en el programa (complejo)
mantenimiento. Para esto, icmake ofrece varios operadores especiales, así como un conjunto de soporte
funciones que han demostrado su utilidad en el mantenimiento de programas.

El programa icmun(1) se puede utilizar para desensamblar el archivo de código de bytes (.bim) compilado. Icmún
se utiliza principalmente para ilustración, educación y depuración.

Las utilidades tradicionales de make vuelven a compilar las fuentes una vez que se modifican los archivos de encabezado. En el
contexto de C + + desarrollo del programa, esto a menudo es una mala idea, ya que agregar un nuevo miembro a un
class normalmente no requiere que recompile las fuentes de la clase. Para manejar la clase
dependencias icmbldo(1) puede inspeccionar CLASES archivos que se pueden usar para definir dependencias
entre clases. De forma predeterminada, las dependencias de clase no se interpretan. Referirse a icmconf(7)
man-page para más detalles.

CAMPUS

Yo hago utiliza los siguientes archivos y opciones:

o fuente: icmake archivo de origen de script (extensión predeterminada: .soy).

o dest: binario icmake archivo de script (predeterminado: `fuente '. bim, llamado el `archivo .bim '
abajo).

o --: icmake separador de argumentos separando icmake argumentos de argumentos pasados
al archivo .bimnl () args: argumentos siguientes -- se pasan al archivo .bim
tal cual, y están disponibles en el lista argv parámetro definido como el icmake
guiones principal segundo parámetro de la función (ver más abajo en la sección USUARIO DEFINIDO
Las funciones). Para algunas opciones (ver a continuación) el -- no se requiere separador.

Yo hago admite varias opciones, que se describen a continuación. El -h la opción anula todas las demás
opciones, el -a opción anula todas las demás opciones excepto -h. De la acción restante
opciones (-B, -C, -mi, -I, -p y -t) solo se puede especificar uno:

o -a
mostrar información sobre icmake, anulado por -h;

o -b
descontinuado: use la opción -e en su lugar;

o -c
las icmake se compila el archivo fuente, generando un archivo .bim;

o -e
ejecutar el icmake archivo .bim, dado como icmakeprimer argumento de archivo. Algo adicional
los argumentos se pasan al archivo .bim tal cual, y -- no debe especificarse;

o -F
los nombres de archivo y banderas, así como una descripción general de todas las acciones que debe realizar
icmake se muestran en el flujo de salida estándar;

o -h
proporcionar información de uso y finalizar icmake;

o -i
el primer argumento es el icmake archivo de origen, el archivo binario predeterminado es
construido si es necesario. Cualquier argumento adicional se pasa al archivo .bim
tal cual, y -- no debe especificarse;

o -p
las icmake El archivo de origen solo está preprocesado y el archivo preprocesado se escribe
a icmakesegundo argumento de archivo (por defecto `fuente '.pim);

o -q
ignorado, será eliminado en un futuro icmake versión;

o -t
el argumento siguiente -t es el nombre de un archivo .bim temporal, que se elimina
después de icmakellamada. Cuándo . se especifica como el nombre del archivo .bim temporal
luego el directorio temporal predeterminado, seguido de icmakeID de proceso, seguido de
.bim se utiliza.

Después del nombre del archivo .bim temporal, el nombre del icmake secuencia de comandos de origen
debe especificarse. Cualquier argumento adicional se pasa al archivo .bim tal cual, y
-- no debe especificarse; Después de configurar el indicador ejecutable del archivo de secuencia de comandos de origen
(chmod +x guión), y proporcionándole una línea inicial como esta:

#! / usr / bin / icmake -t.

las icmake El script se puede llamar directamente:

secuencia de comandos arg1 arg2

en cuyo caso el icmake guión 'guión' se ejecuta mientras recibe el
argumentos guión arg1 arg2.

o -T
esta opción debe proporcionarse con el nombre de un directorio que se utiliza para almacenar
archivos temporales. Por ejemplo, al compilar un icmake script, la salida de icmake,
El preprocesador es un archivo temporal que se elimina al salir. Por defecto / Tmp es usado
a menos que / Tmp no es un directorio grabable, en cuyo caso el usuario actual $ HOME
se utiliza el directorio. Los nombres de archivo temporales implícitos siempre comienzan con el ID de proceso de
la corriente icmake .

o -v
la visualización icmakeel número de versión y el final icmake, anulado por -h

Icmún:

archivo bim: binario icmake archivo de comandos.

PREPROCESADOR DIRECTIVAS

Están disponibles las siguientes directivas de preprocesador:

o comentario:
estándar C comentario (todo entre /* y */) así como del comentario al final de la línea (todos
contenido de la línea siguiente //) se ignoran.

o Inicio de Shell: la primera línea del icmake-script puede comenzar con #!sendero, Donde
camino define la ubicación absoluta de la icmake programa. Haciendo el guion
ejecutable, se puede llamar sin llamar explícitamente icmake.

Por ejemplo, si la primera línea de un icmakefile (ejecutable) 'icm' (sin extensión)
contiene

#! / usr / bin / icmake -i

luego icm puede ser emitido como un comando, ejecutando

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

Alternativamente,

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

puede ser utilizado, resultando en la ejecución de

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

En este caso, el archivo binario se elimina al salir.

o #incluir "nombre del archivo"
El archivo nombre de archivo se incluye en la ubicación de la directiva

o #incluir
El archivo nombre de archivo se incluye en la ubicación de la #incluir directiva; nombre de archivo
se busca en los directorios separados por dos puntos especificados por el IM entorno
variable. La primera aparición de nombre de archivo en los directorios especificados por el IM
se utiliza la variable de entorno.

o #definir identificador [definición]
El texto identificador será reemplazado por definición. La definición puede contener
referencias a identificadores ya definidos, utilizando el $ {identifier} formato. Si el
$ {identifier} no ha sido definido (todavía), el texto $ {identifier} se guarda literalmente.
Para evitar la recursividad infinita como máximo 100 $ {identifier} se permiten reemplazos.

Las definiciones continúan en la siguiente línea si el último carácter de una línea es un
barra invertida\). (que no está incluido en la definición). El preprocesador
concatena cadenas entre comillas dobles, y las cadenas entre comillas dobles no pueden abarcar múltiples
líneas. Múltiples espacios en blanco (fuera de las cadenas entre comillas dobles) en las definiciones son
contratado a un solo espacio en blanco.

La definición que sigue a la # define's el identificador es opcional. Si se omite, el
La macro está definida, por lo que se puede utilizar en # si (n) def directivas (ver más abajo), pero ellos
no son reemplazados por ningún texto en icmake declaraciones de código.

o #ifdef identificador
Si identificador macro se definió el siguiente bloque de código (hasta una coincidencia #else
or #terminara si se leyó la directiva) se compila por bytes. De lo contrario, el bloque de código es
ignorado

o #siempre identificador
Si identificador macro fue no definió el siguiente bloque de código (hasta que una coincidencia
#else or #terminara si se detectó la directiva) se compila en bytes. De lo contrario, el bloque de
se ignora el código.

o #else
Termina un #ifdef y #siempre directiva, revirtiendo la decisión de aceptación sobre
el siguiente código. Solo uno #else La directiva se puede asociar con # si (n) def
directivas

o #terminara si
Termina el bloque de preprocesador comenzando en la coincidencia #ifdef, #siempre or #else
directiva. los #terminara si directorio y su coincidencia # si (n) def la directiva debe ser
especificado en el mismo archivo.

o #undef identificador
Eliminar identificador del conjunto de símbolos definidos. Esto no afecta al
especificación de cualquier símbolo previamente definido en el que identificador definición
ha sido usado. Si identificador no se ha definido se emite una advertencia.

DATOS TIPOS

Yo hago admite estos tipos de datos:

o ASCII personaje constante
Las constantes de caracteres ASCII constan de un carácter, rodeado por simple o doble
citas. Caracteres individuales (p. Ej., 'a') representan el personaje en sí. Estándar
secuencias de escape (p. ej., '\norte') son compatibles y representan su estándar convertido
valor (p. ej., '\norte' representa el valor ascii 10 (decimal)). Escape no estándar
secuencias (p. ej., '\X') representan el carácter ascii que sigue al carácter de escape
(entonces '\X' iguales 'X'). Las secuencias de escape que constan de tres dígitos octales representan
el carácter ascii correspondiente al valor octal módulo 256 (por ejemplo, '\ 123').
Las secuencias de escape que constan de una x seguida de dos dígitos hexadecimales representan
el carácter ascii correspondiente al valor hexadecimal (p. ej., '\ xa4').

o int
Valores integrales, que van desde -0x8000 a 0x7fff. int las constantes pueden ser
especificado como números decimales (comenzando con los dígitos del 1 al 9), números octales
(comenzando con 0, seguido de uno o más dígitos octales) números hexadecimales
(comenzando con 0x, seguido de uno o más dígitos hexadecimales) o como ASCII
constantes de caracteres.

o cadena
Variables de texto. Las constantes de cadena están delimitadas por comillas dobles. Cadena múltiple
Las constantes pueden concatenarse, pero una sola constante de cadena no puede abarcar múltiples
líneas. Constantes de cadena separadas solo por espacios en blanco (es decir, espacios en blanco, líneas nuevas,
comentario) están concatenados y representan una sola constante de cadena. Para indicar un
fin de línea en una constante de cadena use el \n secuencia de escape.

Las constantes de caracteres ASCII rodeadas por comillas dobles también se pueden utilizar en
expresiones aritméticas si uno de los operandos es un int. El personaje único
constante de cadena debe ser una constante, y no puede ser una cadena variable.

Asimismo, las constantes de caracteres ASCII rodeadas por comillas simples se pueden utilizar en
situaciones en las que se espera un operando de cadena.

o lista
Una estructura de datos que contiene una serie de datos accesibles individualmente. cadena valores. Cuando
una lista contiene elementos, su primer elemento está indicado por el índice 0.

o vacío
Se usa con definiciones de función para indicar que la función no devuelve un
.

Las variables se pueden definir a nivel global así como a cualquier nivel local dentro
funciones. Cuando se define dentro de las funciones, el estándar C reglas de alcance y visibilidad
solicitar. Por ejemplo, las variables locales solo se pueden usar por sí mismas o en anidaciones más profundas.
bloques, su visibilidad se enmascara en bloques más profundamente anidados mediante la definición de un idéntico
variable nombrada dentro de esos bloques anidados más profundamente. Las variables están fuertemente tipadas y
no puede tener tipo vacío.

Las variables se pueden inicializar cuando se definen. Las inicializaciones son expresiones, que
Puede utilizar funciones predefinidas o definidas por el usuario, valores constantes y valores de variables que son
visible en el punto de definición.

PREDEFINIDO Constantes

Las siguientes constantes están predefinidas por icmake. Todos son constantes int valores:

─────────────────────────────────
valor de símbolo destinado a
─────────────────────────────────
O_ALL 8 lista de creación
Makelist de O_DIR 2
O_FILE 1 lista de creación
Lista de creación de O_SUBDIR 4
─────────────────────────────────
APAGADO 0 eco
EN 1 eco
─────────────────────────────────
P_CHECK 0 llamadas al sistema
P_NOCHECK 1 llamadas al sistema
─────────────────────────────────
Estadísticas S_IEXEC 32
S_IFCHR 1 estadística
Estadística S_IFDIR 2
Estadísticas S_IFREG 4
Estadísticas S_IREAD 8
Estadísticas S_IWRITE 16
─────────────────────────────────

Las siguientes constantes dependen de la arquitectura:

────────────────────────────────────────────────── ────────────
símbolo 1 cuando se define en la plataforma, de lo contrario 0
────────────────────────────────────────────────── ────────────
unix Unix, normalmente con el compilador gcc de GNU
UNIX puede estar disponible alternativamente
linux x86 ejecutando Linux (generalmente con gcc)
Alternativamente, LINUX puede estar disponible
M_SYSV, M_UNIX x86 con SCO / Unix
_POSIX _SOURCE Unix con compilador compatible con Posix
__hpux HP-UX, con el compilador nativo de HP
────────────────────────────────────────────────── ────────────

OPERADORES

tipo int operando (s):

Todos C los operadores están disponibles (excepto para los operadores de puntero, como icmake no soporta
punteros). Operan como sus C- Lenguaje de programación homólogos.

escrito en cadena operando (s):

cadena tipo de variables y / o constantes los siguientes operadores están disponibles (a y b
representar cadena variables o constantes):

o a + b: devuelve un nuevo cadena valor que contiene la concatenación de cadena valores a
y b. Tenga en cuenta que cadena Las constantes se pueden concatenar directamente (sin usar la +
operador), por ejemplo, las dos líneas siguientes definen la cadena "Hola mundo":

"Hola Mundo"
"hola" + "mundo"

o a += b: a debe ser un cadena variable, a la que el cadena variable o valor b is
adjunto.

o comparaciones de cadenas: operadores == != <= >= < > != y == puede aplicarse a cadena
valores o variables, devolviendo 1 si la comparación tiene éxito, en caso contrario 0.
La comparación distingue entre mayúsculas y minúsculas y sigue el orden o los caracteres definidos
existentes ASCII conjunto de caracteres.

o !a: el booleano ! El operador (no) devuelve 1 si el cadena a está vacío, de lo contrario 0 es
devuelto.

o a más joven b, a más nuevo b: devuelve 1 si archivo a es más reciente que el archivo b. P.ej,
"fuente.cc" más nuevo "fuente.o". Los archivos a y b no tiene que existir: si ambos no
existe 0 se devuelve; Si b no existe, se devuelve 1; Si a no existe 0 es
regresó; si tienen la misma antigüedad, se devuelve 0. (el existe () función predefinida
(ver más abajo, sección PREDEFINIDO Las funciones) se puede utilizar para probar explícitamente si un
El archivo existe).

o a mayor b: cumple 1 si archivo a es más antiguo que el archivo b. P.ej, "libprog.a" mayor
"fuente.o". Los archivos a y b no tiene que existir: si ambos no existen, 0 es
regresó; Si a no existe, se devuelve 1; Si b no existe 0 se devuelve; Si
son igualmente antiguos. 0 se devuelve.

o []: el operador de índice recupera un carácter de una variable de cadena o constante:
devuelve una cadena como un valor. Por lo tanto, la siguiente declaración se compila correctamente:

// asume que str1 y str2 son cadenas
str1 = str2 [3];

pero la siguiente declaración no se compilará:

str2 [3] = "a";

Se devuelve una cadena vacía si se proporciona un valor de índice no válido.

o El operador de comillas invertidas (`cadena cmd`)
Una cadena colocada entre dos comillas inversas es ejecutada por el papa(3) función. El
La salida estándar generada por el comando que se almacena en el argumento de cadena es
devuelto como una lista. Una lista vacía indica que el comando no se pudo ejecutar.
Un comando que podría ejecutarse pero no produjo ningún resultado devuelve una lista
que contiene un elemento vacío. La salida de flujo de error estándar del comando no es
recopilado por el operador de comillas invertidas. Sin embargo, la redirección de shell estándar podría ser
utilizado para recopilar la salida de la secuencia de error estándar. Ejemplo:

printf (`" ls "`); // imprime los elementos en
// el directorio actual

La función predefinida eval (cadena cmd) se comporta exactamente como la comilla invertida
operador: son sinónimos.

tipo lista operando (s):

lista tipo de variables y / o valores, los siguientes operadores están disponibles:

o a + b: devuelve un nuevo lista valor que contiene la concatenación de lista valores a y
b. Es no una operación de conjunto: si un elemento aparece tanto en a y en b, ellos van a
aparecen dos veces en la lista resultante (la adición de conjuntos la proporciona el
función unión).

o a - b: devuelve un nuevo lista valor que contiene los elementos en a que no estan presentes
in b. Esto is una operación de diferencia de conjuntos: la lista devuelta contiene todos los elementos
in a que no son elementos de b.

o a += b: elementos en b se agregan a los elementos en a, que debe ser un lista
variable. Esto es no una operación establecida.

o a -= b: elementos en b se eliminan de los elementos en a, que debe ser un lista
variable. Esto is una operación de conjunto: todos los elementos de a que se encuentran en b en
retirado de a.

o enumerar comparaciones de igualdad: operadores != y == puede aplicarse a lista valores o
variables. Operador == devuelve 1 si ambas listas tienen elemento por elemento idéntico
elementos, de lo contrario se devuelve 0. Operador != invierte el resultado de ==.

o !a: el booleano ! El operador devuelve 1 si el lista a está vacío, de lo contrario 0 es
devuelto.

o []: el operador de índice recupera un elemento de lista de una variable de lista: devuelve un
cadena como un valor. Por lo tanto, la siguiente declaración se compila correctamente:

// asumimos que lst es una lista, str es una cadena
str = lst [3];

pero la siguiente declaración no se compilará:

lst [3] = str;

Se devuelve una cadena vacía si se proporciona un valor de índice no válido.

de calidad:

Los tipos de molde se pueden realizar utilizando el estándar C Cast-operator para emitir:

o Cadenas a ints y viceversa ((int) "123", (cuerda) 55)

o Cadenas a listas (lista LST = (lista) "hola")

FLUJO CONTROL

Yo hago ofrece el siguiente subconjunto de Cdeclaraciones de. Se pueden utilizar como en el C
lenguaje de programación.

o expresión ;
La declaración de expresión simple;

o La declaración compuesta
Las variables de cualquier tipo se pueden definir e inicializar en cualquier lugar dentro de cualquier compuesto.
declaración. La la visibilidad de una variable comienza en su punto de definición.

o if (condición) ambiental
Dentro de la condición se puede definir e inicializar una variable. P.ej,

si (cadena str = getText ())
proceso (str);

En este ejemplo, no se llama si getText () devuelve una cadena vacía. El
variable str no existe ni antes ni después de la if .

o if (condición) ambiental más ambiental
Al igual que con la declaración anterior, dentro de la condición se puede definir una variable y
inicializado.

o para (en eso; condición; incremento) ambiental
Las variables (de un solo tipo) pueden inicializarse (y opcionalmente definirse) en el
init sección. los init, condición y incremento las secciones pueden permanecer vacías. El
La sección de condición vacía se interpreta como `siempre verdadero".

o mientras (condición) ambiental
Dentro de la condición se puede definir e inicializar una variable.
Un complementario do ... while () declaración no está disponible. Tenga en cuenta que definir un
variable, el uso de una expresión de inicialización significa que la inicialización
La expresión se ejecuta en cada iteración del mientras declaración. Entonces lo siguiente
La declaración nunca terminará y mostrará un flujo interminable de valores 10:

mientras (int x = 10)
printf (x--, "\ n");

o volver;y volvemos expresión;
Natural volvemos las declaraciones se pueden utilizar en vacío funciones, y volvemos expresión
Las declaraciones se utilizan en otro tipo de funciones. La función principal tiene tipo de retorno
vacío y así en principal solo llano volvemos Se pueden utilizar declaraciones. Por defecto un icmake
el valor de salida del script es igual a 0. Utilice la función incorporada salida (ver más abajo) para especificar
cualquier otro valor de salida.

Be aconsejado: el comportamiento de las funciones no nulas que no devuelven valores no está definido.

o romper
Ramas y Hojas para y mientras declaraciones, anulando la condición de la declaración.

o continue
Continúa con la siguiente iteración de un para or mientras .

o salir (expresión)
Finaliza la ejecución de un icmake-texto. El expresión debe evaluar a un int
value, que se convierte en el valor de salida del script.

PREDEFINIDO Las funciones

Yo hago ofrece las siguientes funciones predefinidas, que se pueden utilizar en cualquier lugar de icmake
guiones. La siguiente descripción general está ordenada alfabéticamente por nombre de función.

o vacío arghead (cuerda h)
Función auxiliar de exec () (ver también más abajo en exec ()): define el "encabezado del argumento",
para ser utilizado con exec (). De forma predeterminada, el "encabezado del argumento" es una cadena vacía.

o vacío cola de caballo (cuerda t)
Función auxiliar de exec () (ver también más abajo en exec ()): define la 'cola del argumento',
para ser utilizado con exec (). Por defecto, el "argumento cola" es una cadena vacía.

o int ascii (cuerda s)
Devuelve el primer carácter de s como un int; p.ej, ascii ("A") devuelve 65;

o cadena ascii (int i)
Returns i como una cuerda, p. ej., ascii(65) devuelve la cadena "A";

o cadena change_base (cadena archivo, cadena nueva base)
Cambia el nombre base de presentar, devuelve el nombre cambiado. P.ej,
change_base ("/ ruta / demo.im", "fuera") devoluciones "/ruta/out.im";

o cadena change_ext (cadena archivo, cadena nuevoext)
Cambia la extensión de presentar, devuelve el nombre cambiado. P.ej,
rss_changeExt ("fuente.cc", "o") devoluciones "fuente.o";

o cadena change_path (cadena archivo, cadena nuevo camino)
Cambia la especificación de ruta de presentar, devuelve el nombre cambiado. P.ej,
change_path ("tmp / binary", "/ usr / bin") devoluciones "/ usr / bin / binary". Tenga en cuenta que el
/-se inserta un separador si es necesario.

o cadena chdir (cadena nuevodir)
Cambia el directorio de trabajo del script, devuelve el directorio anterior como absoluto
camino.

Uso chdir (".") para obtener el directorio de trabajo actual, chdir ("") puede ser usado para
obtener el directorio de trabajo de inicio (esta funcionalidad se rompió en las versiones
antes de las 7.00, pero ahora está operativo). La función termina el
icmake-script si el especificado nuevodir no existe.

o cadena chdir (int comprobación, cadena nuevodir)
Misma funcionalidad que la función anterior, pero especificando comprobación as
P_NOCHECK. la función no terminará el script. Más bien, devolverá el
directorio de trabajo actual del script.

o cmdhead (cadena h)
Función auxiliar de exec () (ver también más abajo en exec ()): Define un "cabezal de comando", para
ser usado con exec (). Por defecto, el "encabezado de comando" es una cadena vacía.

o cmdtail (cuerda t)
Función auxiliar de exec () (ver también más abajo en exec ()): Define una `cola de comando ', para
ser usado con exec (). Por defecto, el "comando cola" es una cadena vacía.

o echo (int optar)
Controla el eco de los programas llamados (y sus argumentos), especifique OFF si resuena
no se solicita. Por defecto echo (ENCENDIDO) se utiliza.

o cadena elemento (int índice, lista (o cadena) var)
Actúa de forma idéntica al operador de índice: consulte el índice ([]) operador en el
. OPERADORES.

o lista eval (cadena calle)
Esta función actúa de manera idéntica al operador de comillas invertidas. El ejemplo proporcionado con
Por lo tanto, el operador de comillas invertidas también podría haberse escrito así:

printf (eval ("ls")); // imprime los elementos en el actual
// directorio

o exec (cadena cmd ...)
Ejecuta comando con argumentos. Cada argumento tendrá el prefijo arghead (),
argumento y posfijado por argtail ()Argumento de. Tenga en cuenta que no se insertan espacios en blanco
entre arghead ()contenido, el argumento propiamente dicho, y argtail ()Argumento de. Todo
así los argumentos modificados se concatenan, esta vez separados por espacios en blanco simples, y
luego cmdhead ()El contenido se inserta entre el comando y el primer argumento.
(a cada lado delimitado por espacios en blanco simples) y cmdtail ()se adjuntan los contenidos
a los argumentos (de nuevo, separados por un solo espacio en blanco). TRAYECTORIA se busca para localizar
cmd. Se devuelve 0.

o ejecutivo (int comprobar cmd, cadena cmd ...)
Misma funcionalidad que la función anterior, pero especificando comprobación as
SIN REVISAR la función no terminará el script. Más bien, devolverá el
estado de salida del comando llamado, o 0x7f00 si no se encontró el comando.

o ejecutar (cadena cmd cadena cmdhd, cadena arghd, ... cadena argtl, cadena cmdtl)
Igual que exec (), pero se deben especificar el comando head / tail y el argumento head / tail.

El comando realmente ejecutado comienza con cmd (XNUMX %) cmdhd. Lo siguiente es una serie
de argumentos sigue, cada uno encerrado por Arghd y argtl. El comando termina con
cmdtl. 0 se devuelve

o ejecutar (int comprobación, cadena cmd cadena cmdhd, cadena arghd, ... cadena argtl,
cadena cmdtl)
Misma funcionalidad que la función anterior, pero especificando comprobación as
SIN REVISAR la función no terminará el script. Más bien, devolverá el
estado de salida del comando llamado, o 0x7f00 si no se encontró el comando.

o int existe (cadena archivo)
Devuelve un valor distinto de cero si presentar existe, de lo contrario se devuelve 0.

o lista fgets (cadena archivo, lista compensar)
NOTA: in icmake versión 8.00.00 el prototipo de esta función se cambió de
lista fgets (cadena archivo, int compensar) a lista fgets (cadena archivo, lista compensar).

La siguiente línea que se encuentra en el desplazamiento contenido en compensar se lee de presentar. Pasar un
lista vacía para fgets leer presentar desde su inicio.

Devuelve una lista que contiene como primer elemento el contenido de la línea de lectura.
(sin el \n terminador de línea), como segundo elemento el terminador de línea `\n'
(si se encuentra), y como tercer elemento la cadena OK si una línea fue exitosa
leer FALLO si la lectura del archivo falló. Cuando se lee en EOF, se muestra una lista vacía.
regresó. La lista devuelta puede contener elementos adicionales, que son internamente
utilizado por fgets al leer la siguiente línea.

Para leer varias líneas, comience pasando una lista vacía como consigue segundo argumento.
Para leer las líneas siguientes, pase la lista devuelta anteriormente a fgets's segundo
argumento.

A continuación, se muestra un ejemplo que muestra cómo leer un archivo completo:

lista ret;
mientras que (1)
{
ret = fgets ("nombre de archivo", ret);
si (! ret)
break;
proceso (ret [0], ret [1]);
}

o int fprintf (cadena nombre del archivo, ...)
Agrega todos los argumentos (separados por comas) al archivo nombre de archivo. Devuelve el número de
argumentos impresos.

o int fprintf (cadena nombre del archivo, cadena formato, ...)
Agrega todos los argumentos (separados por comas) al archivo nombre de archivo. Devuelve el número de
argumentos impresos.

If formato contiene marcadores de posición% 1 ..% n la salida está formateada (ver también
formato de cadena). Tenga en cuenta que en este caso el recuento de argumentos (también) comienza más allá del
cadena de formato: el primer argumento siguiente formato es referido como %1.

o cadena get_base (cadena archivo)
Devuelve el nombre base de presentar. El nombre base es el archivo sin su prefijo de ruta
y sin su extensión. La extensión es toda la información a partir de la final.
punto en el nombre del archivo. Si no se encuentra ningún punto final, el nombre del archivo es el nombre base.
Por ejemplo, el nombre base de ab iguales a, el nombre base de a B C iguales ab, la base
nombre de a B C iguales c.

o cadena getch ()
Devuelve la siguiente tecla presionada como una cadena (presionar 'Enter' no es necesario).

o cadena get_dext (cadena archivo)
Devuelve la extensión de presentar, incluido el punto de separación. La extensión es todo
información que comienza en el punto final del nombre de archivo.

Si no se encuentra ningún punto final, se devuelve una cadena vacía.

o lista getenv (cadena envvar)
Devuelve el valor de la variable de entorno. envvar en una lista que contiene dos elementos:

el primer elemento indica si se definió la variable de entorno (valor
"1") o no (valor "0");
el segundo elemento indica el valor de la variable de entorno.

Las variables ambientales tienen la forma variable = valor, y si se define la lista
el segundo elemento contiene propuesta de. Si el valor está vacío, la variable está definida, pero
no tiene texto asociado.

o cadena get_ext (cadena archivo)
Devuelve la extensión de presentar, excepto por el punto de separación. La extensión es todo
información que comienza en el último punto del nombre del archivo.

Si no se encuentra ningún punto final, se devuelve una cadena vacía.

o int getpid ()
Devuelve el identificador de proceso del intérprete de código de bytes icmake icm-ejecutivo.

o cadena obtiene()
Devuelve la siguiente línea leída desde el teclado como un cadena. La línea ingresada en el
El teclado debe terminar con una tecla 'Enter', que no se almacena en el
cadena.

o cadena get_path (cadena archivo)
Devuelve el prefijo de ruta de presentar. El prefijo de ruta es toda la información hasta (y
incluyendo) el separador de directorio final (que es, dependiendo de la operación
sistema, una barra inclinada hacia adelante o hacia atrás).

Si no se encuentra ninguna ruta, se devuelve una cadena vacía.

o int listfind (lista primero, cadena calle)
Devuelve el primer índice en LST donde la cuerda str se encuentra, o -1 si LST no
que no contengo str.

o int listlen (lista l)
Devuelve el número de elementos en lista.

o lista listunion (lista izquierda, lista derecho)
Devuelve una lista que contiene la unión de los elementos en lhs y RHS.

o lista listunion (lista primero, cadena calle)
Devuelve una lista que contiene la unión de los elementos en LST y str.

o lista makelist (cuerda máscara)
Devuelve una lista de todos los archivos que coinciden máscara. P.ej, makelist ("*. c") devuelve una lista
que contiene todos los archivos que terminan en .c.

o lista makelist (tipo, cadena máscara)
Igual que la función anterior, pero el tipo de elementos del directorio puede ser
especificado como su primer argumento:

significado del símbolo
IS_ALL obtiene todas las entradas del directorio
IS_DIR obtiene todos los directorios, incluido. y ..
IS_FILE obtener una lista de archivos
IS_SUBDIR obtiene todos los subdirectorios

Tenga en cuenta que el patrón * no coincidirá con las entradas ocultas en el funcionamiento de tipo Unix
sistemas. Usar .* para eso.

o lista makelist (cuerda máscara, más nuevo, cadena comparar archivo)
Devuelve una lista de todos los archivos que coinciden con la máscara que son más nuevos que los proporcionados.
comparefile. Operador más joven puede usarse en lugar de más nuevo. Tenga en cuenta que más nuevo y
más joven son operadores, no cadenas.

o lista makelist ([int = ES_ARCHIVO,] cadena máscara, más nuevo, cadena comparar archivo)
Igual que la función anterior, pero tipo puede especificarse como en lista makelist (tipo,
cadena máscara).

o makelist (cuerda máscara, más viejo, cadena comparar archivo)
Véase más arriba; devuelve una lista de archivos que son más antiguos que el archivo de comparación.

o makelist (tipo, cadena máscara, más viejo, cadena comparar archivo)
Igual que la función anterior, pero tipo puede especificarse como en lista makelist (tipo,
cadena máscara).

o int printf (...)
Muestra todos los argumentos (separados por comas) en la pantalla (es decir, el flujo de salida estándar).
Devuelve el número de argumentos impresos.

o int printf (cadena formato, ...)
Muestra todos los argumentos (separados por comas) en la pantalla (es decir, el flujo de salida estándar).
Devuelve el número de argumentos impresos (el formato cadena cuenta como un argumento).

If formato contiene marcadores de posición% 1 ..% n la salida está formateada (ver también
formato de cadena).

o int putenv (cuerda envvar)
Añade envvar a la corrienteicmake) entorno Utilice el formato: "VAR = valor".
Devuelve 0.

o cadena redimensionar (cadena calle, int nueva longitud) Devuelve una copia de la cadena str, redimensionado a
nueva longitud caracteres. Si nueva longitud es negativo, se devuelve una cadena vacía,
if nueva longitud excede str's longitud, los caracteres recién agregados se inicializan
a espacios en blanco.

o int sizeof (lista l)
En desuso: uso escucha.

o int sizeoflist (lista l)
En desuso: uso escucha.

o lista stat (cadena entrada)
Returns stat(2) información de la entrada del directorio entrada como una lista. La lista devuelta
tiene dos elementos: el elemento 0 es el atributo propuesta de, el elemento 1 contiene el tamaño de
el archivo.

Los atributos se devuelven como indicadores de bits, compuestos de los siguientes valores predefinidos
constantes:

S_IFCHR S_IFDIR S_IFREG
S_ILEER S_IESCRIBIR S_IEXEC

Consulte las stat(2) página de manual para el significado de estas constantes.

o lista stat (comprobando, cadena entrada)
Igual que la función anterior, pero especificando comprobación as P_NOCHECK la función
no terminará el script. Más bien, vuelve statValor de retorno de (2).

o int strchr (cuerda calle, cadena caracteres)
Devuelve el primer índice en str donde alguno de los personajes de caracteres se encuentra, o -1
if str no contiene ninguno de los caracteres en caracteres.

o int strlen (cuerda calle)
Devuelve el número de caracteres en str (sin contar el 0 final).

o int strfind (cadena alpaca, cadena aguja)
Devuelve el índice en alpaca donde aguja se encuentra, o -1 si aguja no está contenido
in alpaca.
Este función fue , que son strstr () in versiones antes 7.00.

o int strformat (cadena formato,...)
Devuelve una cadena formateada utilizando marcadores de posición% 1 ..% 2 para abordar los argumentos
siguiente formato.
Ejemplo:

void principal ()
{
int i = 10;
int j = 20;
cadena s1;
cadena s2;
// enfoque tradicional:
s1 = (cadena) i + "" + (cadena) j + "" + (cadena) i;
// usando strformat:
s2 = strformat ("% 1% 2% 1", i, j);
printf ("s1 =% 1, s2 =% 2 \ n", s1, s2);
}

o cadena strlwr (cadena s)
Devuelve un duplicado en minúscula de s.

o lista strtok (cadena calle, cadena separadores)
Devuelve una lista que contiene todas las subcadenas de str separados por uno o más
caracteres (consecutivos) en separadores. P.ej, strtok ("hola icmake's + world ", " + ")
devuelve la lista que contiene las tres cadenas "Hola", "icmake's"y "mundo".

o cadena strupr (cuerda s)
Devuelve un duplicado en mayúsculas de s.

o cadena substr (cadena texto, int compensar, int contar)
Devuelve una subcadena de texto, A partir de compensar, que consiste en contar caracteres. Si
compensar excede (o iguala) el tamaño de la cadena o si contar <= 0, luego una cadena vacía
es regresado. Si compensar es menor que 0, entonces se usa 0.

o int sistema (cadena mando)
Ejecuta comando. El valor de retorno indica el valor de salida del comando ejecutado. El
cadena comando puede contener caracteres de redireccionamiento y / o canalizaciones.

o int sistema (int comprobación, cadena mando)
Misma funcionalidad que la función anterior, pero especificando comprobación as
SIN REVISAR la función no terminará el script. Más bien, devolverá el
estado de salida del comando llamado, o 0x7f00 si no se encontró el comando.

o cadena recortar (cuerda s)
Devuelve una copia de s sin espacios en blanco iniciales y finales.

o cadena trimleft (cuerda calle)
Devuelve una copia de s sin espacios en blanco iniciales.

o cadena recortar (cuerda s)
Devuelve una copia de s sin dejar espacios en blanco.

USUARIO DEFINIDO Las funciones

vacío principal

Yo hago Los scripts deben contar con una función definida por el usuario. principal. La función principal tiene
tres parámetros opcionales, que pueden omitirse del último (envp) al primero
(argc), como en C. Su prototipo completo es (nota: vacío tipo de retorno):

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

In principal(),

o argc representa el número de elementos en argv;

o argv contiene los argumentos, siendo el elemento 0 igual al nombre del .bim
archivo;

o envp contiene las variables de "entorno". La función escucha puede ser usado para
determinar el número de sus elementos. Elementos en envp tener la forma
variable = valor. Alternativamente, la función conseguir se puede utilizar para recuperar un
variable de entorno específica inmediatamente. Ejemplo:

principal vacío (int argc, lista argv)
{
lista para compilar;
int idx;

si (argc == 1)
uso (elemento (0, argv));

if (toCompile = alterado ("*. cc"))
{
para (idx = longitud (para compilar); idx--;)
compilar (elemento (idx, toCompile));

if (getenv ("dryrun") [0] == "0")
enlazando (elemento (2, argv));
}
}

Habiendo inicializado todas las variables globales en el orden de sus definiciones. principal es llamado por
icmakeSistema de soporte en tiempo de ejecución para realizar tareas adicionales.

Adicionalmente se define usuario funciones

Se pueden definir funciones adicionales. Una vez definidas, estas funciones se pueden llamar. Adelante
no se admite la referenciación de variables o funciones, sino llamadas recursivas
funciones es. Como las declaraciones de función no son compatibles, la recursividad indirecta no es
apoyado tampoco.

Las funciones definidas por el usuario deben tener los siguientes elementos:

o El tipo de retorno de la función, que debe ser uno de vacío, En t, cadena or lista. Allí
no es un tipo predeterminado.

o El nombre de la función, por ejemplo, compilar.

o Una lista de parámetros, que define cero o más parámetros separados por comas. Los parametros
ellos mismos consisten en un nombre de tipo (En t, cadenao lista) Seguido por el
identificador del parámetro. P.ej, (cuerda outfile cadena fuente).

o un cuerpo rodeado por un par de llaves ({ y }).

Los cuerpos de las funciones pueden contener definiciones de variables (opcionalmente inicializadas). Variable
Las definiciones comienzan con un nombre de tipo, seguido de una o más comas separadas (opcionalmente
inicializados) identificadores de variables. Si una variable no se inicializa explícitamente, es
inicializado por defecto. Por defecto un int La variable se inicializa a 0, una cadena is
inicializado a una cadena vacía ("") Y un lista se inicializa a una lista de elementos cero.

Además de las definiciones de variables, los cuerpos pueden contener cero o más declaraciones (cf.
. FLUJO CONTROL). Tenga en cuenta que las variables se pueden definir (y opcionalmente inicializar)
en cualquier lugar dentro de las funciones, y también en Si, para y mientras Declaraciones.

El comportamiento de icmake-Los scripts que utilizan funciones no nulas que no devuelven valores no son
definido.

Utilice icmake en línea utilizando los servicios de onworks.net