Liste des commandes 4D pour snippets?

Bonjour

existe-t-il un fichier avec la liste des commandes 4D US + Nr et nom des paramètres afin de pouvoir l’insérer comme snippets dans un éditeur de texte ?

Comme on peut insérer du code 4D dans la balise des pages HTML, ce serait peut-être utile ?
D’avance merci.

Bonjour Luc

A ma connaissance, le nom des commandes et leur numéro sont disponibles dans un fichier XML. En l’analysant tu peux construire la liste correspondant à la version en cours de 4D. C’est comme cela que je fais dans QS_Toolbox dans la partie “Converter EN/FR”
Maintenant pour la liste des paramètres associés, je ne sais pas.

Patrick

Ok merci, et je peux le trouver ou ce fichier XML ?
:?:

Bonjour,
voici ce que j’utilise pour contrôler les champs des tables # des commandes SQL :

CTL_Mot_Cle pour lire les noms des commandes 4D et SQL
CTL_Nom_4D vérifier les noms des champs avec ceux des commandes.

tu trouveras ton bonheur dans : CTL_Mot_Cle

<code 4D>
// Méthode : CTL_Mot_Cle
// –––––––––––––––––––––––––––––––––––––––––––––––––––––
// Description :
// Liste des mots clés utilisés par SQL ET 4D
// 4D : Version 15.1
// –––––––––––––––––––––––––––––––––––––––––––––––––––––
// Date de création et auteur :
// 04/02/2016 Pierre-Guy LECOMPTE
// –––––––––––––––––––––––––––––––––––––––––––––––––––––
// Modifications (date, auteur et but) :
// (23/02/2016) Pierre-Guy LECOMPTE : Ajout le principe de lire directement 4D_CommandsFR.xlf

//
// –––––––––––––––––––––––––––––––––––––––––––––––––––––

// Fonction pour un tableur :
// =CONCATENER(“YT_4DFR{”;TEXTE(LIGNE();"####");"}:="";A1;""")

// Pour les lire :
// /Applications/4D/4D v15/4D v15.1/4D - 2.app/Contents/Resources/fr.lproj/4D_CommandsFR.xlf
// …/4D_ConstantsFR.xlf

TABLEAU TEXTE(YT_SQL;390)

YT_SQL{1}:=“ABS”
YT_SQL{2}:=“ABSOLUTE”
YT_SQL{3}:=“ACTION”
YT_SQL{4}:=“ADD”
YT_SQL{5}:=“AFTER”
YT_SQL{6}:=“ALL”
YT_SQL{7}:=“ALLOCATE”
YT_SQL{8}:=“ALTER”
YT_SQL{9}:=“AND”
YT_SQL{10}:=“ANY”
YT_SQL{11}:=“ARE”
YT_SQL{12}:=“ARRAY”
YT_SQL{13}:=“AS”
YT_SQL{14}:=“ASC”
YT_SQL{15}:=“ASENSITIVE”
YT_SQL{16}:=“ASSERTION”
YT_SQL{17}:=“ASYMMETRIC”
YT_SQL{18}:=“AT”
YT_SQL{19}:=“ATOMIC”
YT_SQL{20}:=“AUTHORIZATION”
YT_SQL{21}:=“AVG”
YT_SQL{22}:=“BEFORE”
YT_SQL{23}:=“BEGIN”
YT_SQL{24}:=“BETWEEN”
YT_SQL{25}:=“BIGINT”
YT_SQL{26}:=“BINARY”
YT_SQL{27}:=“BIT”
YT_SQL{28}:=“BIT_LENGTH”
YT_SQL{29}:=“BLOB”
YT_SQL{30}:=“BOOLEAN”
YT_SQL{31}:=“BOTH”
YT_SQL{32}:=“BREADTH”
YT_SQL{33}:=“BY”
YT_SQL{34}:=“CALL”
YT_SQL{35}:=“CALLED”
YT_SQL{36}:=“CARDINALITY”
YT_SQL{37}:=“CASCADE”
YT_SQL{38}:=“CASCADED”
YT_SQL{39}:=“CASE”
YT_SQL{40}:=“CAST”
YT_SQL{41}:=“CATALOG”
YT_SQL{42}:=“CEIL”
YT_SQL{43}:=“CEILING”
YT_SQL{44}:=“CHAR”
YT_SQL{45}:=“CHARACTER”
YT_SQL{46}:=“CHARACTER_LENGTH”
YT_SQL{47}:=“CHAR_LENGTH”
YT_SQL{48}:=“CHECK”
YT_SQL{49}:=“CLOB”
YT_SQL{50}:=“CLOSE”
YT_SQL{51}:=“COALESCE”
YT_SQL{52}:=“COLLATE”
YT_SQL{53}:=“COLLATION”
YT_SQL{54}:=“COLLECT”
YT_SQL{55}:=“COLUMN”
YT_SQL{56}:=“COMMIT”
YT_SQL{57}:=“CONDITION”
YT_SQL{58}:=“CONNECT”
YT_SQL{59}:=“CONNECTION”
YT_SQL{60}:=“CONSTRAINT”
YT_SQL{61}:=“CONSTRAINTS”
YT_SQL{62}:=“CONSTRUCTOR”
YT_SQL{63}:=“CONTINUE”
YT_SQL{64}:=“CONVERT”
YT_SQL{65}:=“CORR”
YT_SQL{66}:=“CORRESPONDING”
YT_SQL{67}:=“COUNT”
YT_SQL{68}:=“COVAR_POP”
YT_SQL{69}:=“COVAR_SAMP”
YT_SQL{70}:=“CREATE”
YT_SQL{71}:=“CROSS”
YT_SQL{72}:=“CUBE”
YT_SQL{73}:=“CUME_DIST”
YT_SQL{74}:=“CURRENT”
YT_SQL{75}:=“CURRENT_DATE”
YT_SQL{76}:=“CURRENT_DEFAULT_TRANSFORM_GROUP”
YT_SQL{77}:=“CURRENT_PATH”
YT_SQL{78}:=“CURRENT_ROLE”
YT_SQL{79}:=“CURRENT_TIME”
YT_SQL{80}:=“CURRENT_TIMESTAMP”
YT_SQL{81}:=“CURRENT_TRANSFORM_GROUP_FOR_TYPE”
YT_SQL{82}:=“CURRENT_USER”
YT_SQL{83}:=“CURSOR”
YT_SQL{84}:=“CYCLE”
YT_SQL{85}:=“DATA”
YT_SQL{86}:=“DATE”
YT_SQL{87}:=“DAY”
YT_SQL{88}:=“DEALLOCATE”
YT_SQL{89}:=“DEC”
YT_SQL{90}:=“DECIMAL”
YT_SQL{91}:=“DECLARE”
YT_SQL{92}:=“DEFAULT”
YT_SQL{93}:=“DEFERRABLE”
YT_SQL{94}:=“DEFERRED”
YT_SQL{95}:=“DELETE”
YT_SQL{96}:=“DENSE_RANK”
YT_SQL{97}:=“DEPTH”
YT_SQL{98}:=“DEREF”
YT_SQL{99}:=“DESC”
YT_SQL{100}:=“DESCRIBE”
YT_SQL{101}:=“DESCRIPTOR”
YT_SQL{102}:=“DETERMINISTIC”
YT_SQL{103}:=“DIAGNOSTICS”
YT_SQL{104}:=“DISCONNECT”
YT_SQL{105}:=“DISTINCT”
YT_SQL{106}:=“DO”
YT_SQL{107}:=“DOMAIN”
YT_SQL{108}:=“DOUBLE”
YT_SQL{109}:=“DROP”
YT_SQL{110}:=“DYNAMIC”
YT_SQL{111}:=“EACH”
YT_SQL{112}:=“ELEMENT”
YT_SQL{113}:=“ELSE”
YT_SQL{114}:=“ELSEIF”
YT_SQL{115}:=“END”
YT_SQL{116}:=“END-EXEC”
YT_SQL{117}:=“EQUALS”
YT_SQL{118}:=“ESCAPE”
YT_SQL{119}:=“EVERY”
YT_SQL{120}:=“EXCEPT”
YT_SQL{121}:=“EXCEPTION”
YT_SQL{122}:=“EXEC”
YT_SQL{123}:=“EXECUTE”
YT_SQL{124}:=“EXISTS”
YT_SQL{125}:=“EXIT”
YT_SQL{126}:=“EXP”
YT_SQL{127}:=“EXTERNAL”
YT_SQL{128}:=“EXTRACT”
YT_SQL{129}:=“FALSE”
YT_SQL{130}:=“FETCH”
YT_SQL{131}:=“FILTER”
YT_SQL{132}:=“FIRST”
YT_SQL{133}:=“FIRST_VALUE”
YT_SQL{134}:=“FLOAT”
YT_SQL{135}:=“FLOOR”
YT_SQL{136}:=“FOR”
YT_SQL{137}:=“FOREIGN”
YT_SQL{138}:=“FOUND”
YT_SQL{139}:=“FREE”
YT_SQL{140}:=“FROM”
YT_SQL{141}:=“FULL”
YT_SQL{142}:=“FUNCTION”
YT_SQL{143}:=“FUSION”
YT_SQL{144}:=“GENERAL”
YT_SQL{145}:=“GET”
YT_SQL{146}:=“GLOBAL”
YT_SQL{147}:=“GO”
YT_SQL{148}:=“GOTO”
YT_SQL{149}:=“GRANT”
YT_SQL{150}:=“GROUP”
YT_SQL{151}:=“GROUPING”
YT_SQL{152}:=“HANDLE”
YT_SQL{153}:=“HAVING”
YT_SQL{154}:=“HOLD”
YT_SQL{155}:=“HOUR”
YT_SQL{156}:=“IDENTITY”
YT_SQL{157}:=“IF”
YT_SQL{158}:=“IGNORE”
YT_SQL{159}:=“IMMEDIATE”
YT_SQL{160}:=“IN”
YT_SQL{161}:=“INDICATOR”
YT_SQL{162}:=“INITIALLY”
YT_SQL{163}:=“INNER”
YT_SQL{164}:=“INOUT”
YT_SQL{165}:=“INPUT”
YT_SQL{166}:=“INSENSITIVE”
YT_SQL{167}:=“INSERT”
YT_SQL{168}:=“INT”
YT_SQL{169}:=“INTEGER”
YT_SQL{170}:=“INTERSECT”
YT_SQL{171}:=“INTERSECTION”
YT_SQL{172}:=“INTERVAL”
YT_SQL{173}:=“INTO”
YT_SQL{174}:=“IS”
YT_SQL{175}:=“ISOLATION”
YT_SQL{176}:=“JOIN”
YT_SQL{177}:=“KEY”
YT_SQL{178}:=“LAG”
YT_SQL{179}:=“LANGUAGE”
YT_SQL{180}:=“LARGE”
YT_SQL{181}:=“LAST”
YT_SQL{182}:=“LAST_VALUE”
YT_SQL{183}:=“LATERAL”
YT_SQL{184}:=“LEAD”
YT_SQL{185}:=“LEADING”
YT_SQL{186}:=“LEAVE”
YT_SQL{187}:=“LEFT”
YT_SQL{188}:=“LEVEL”
YT_SQL{189}:=“LIKE”
YT_SQL{190}:=“LN”
YT_SQL{191}:=“LOCAL”
YT_SQL{192}:=“LOCALTIME”
YT_SQL{193}:=“LOCALTIMESTAMP”
YT_SQL{194}:=“LOCATOR”
YT_SQL{195}:=“LOOP”
YT_SQL{196}:=“LOWER”
YT_SQL{197}:=“MAP”
YT_SQL{198}:=“MATCH”
YT_SQL{199}:=“MAX”
YT_SQL{200}:=“MEMBER”
YT_SQL{201}:=“MERGE”
YT_SQL{202}:=“METHOD”
YT_SQL{203}:=“MIN”
YT_SQL{204}:=“MINUTE”
YT_SQL{205}:=“MOD”
YT_SQL{206}:=“MODIFIES”
YT_SQL{207}:=“MODULE”
YT_SQL{208}:=“MONTH”
YT_SQL{209}:=“MULTISET”
YT_SQL{210}:=“NAMES”
YT_SQL{211}:=“NATIONAL”
YT_SQL{212}:=“NATURAL”
YT_SQL{213}:=“NCHAR”
YT_SQL{214}:=“NCLOB”
YT_SQL{215}:=“NESTING”
YT_SQL{216}:=“NEW”
YT_SQL{217}:=“NEXT”
YT_SQL{218}:=“NO”
YT_SQL{219}:=“NONE”
YT_SQL{220}:=“NORMALIZE”
YT_SQL{221}:=“NOT”
YT_SQL{222}:=“NTH_VALUE”
YT_SQL{223}:=“NTILE”
YT_SQL{224}:=“NULL”
YT_SQL{225}:=“NULLIF”
YT_SQL{226}:=“NULLS”
YT_SQL{227}:=“NUMERIC”
YT_SQL{228}:=“OBJECT”
YT_SQL{229}:=“OCTET_LENGTH”
YT_SQL{230}:=“OF”
YT_SQL{231}:=“OFFSET”
YT_SQL{232}:=“OLD”
YT_SQL{233}:=“ON”
YT_SQL{234}:=“ONLY”
YT_SQL{235}:=“OPEN”
YT_SQL{236}:=“OPTION”
YT_SQL{237}:=“OR”
YT_SQL{238}:=“ORDER”
YT_SQL{239}:=“ORDINALITY”
YT_SQL{240}:=“OUT”
YT_SQL{241}:=“OUTER”
YT_SQL{242}:=“OUTPUT”
YT_SQL{243}:=“OVER”
YT_SQL{244}:=“OVERLAPS”
YT_SQL{245}:=“OVERLAY”
YT_SQL{246}:=“PAD”
YT_SQL{247}:=“PARAMETER”
YT_SQL{248}:=“PARTIAL”
YT_SQL{249}:=“PARTITION”
YT_SQL{250}:=“PATH”
YT_SQL{251}:=“PERCENTILE_CONT”
YT_SQL{252}:=“PERCENTILE_DISC”
YT_SQL{253}:=“PERCENT_RANK”
YT_SQL{254}:=“POSITION”
YT_SQL{255}:=“POWER”
YT_SQL{256}:=“PRECISION”
YT_SQL{257}:=“PREPARE”
YT_SQL{258}:=“PRESERVE”
YT_SQL{259}:=“PRIMARY”
YT_SQL{260}:=“PRIOR”
YT_SQL{261}:=“PRIVILEGES”
YT_SQL{262}:=“PROCEDURE”
YT_SQL{263}:=“PUBLIC”
YT_SQL{264}:=“RANGE”
YT_SQL{265}:=“RANK”
YT_SQL{266}:=“READ”
YT_SQL{267}:=“READS”
YT_SQL{268}:=“REAL”
YT_SQL{269}:=“RECURSIVE”
YT_SQL{270}:=“REDO”
YT_SQL{271}:=“REF”
YT_SQL{272}:=“REFERENCES”
YT_SQL{273}:=“REFERENCING”
YT_SQL{274}:=“REGR_AVGX”
YT_SQL{275}:=“REGR_AVGY”
YT_SQL{276}:=“REGR_COUNT”
YT_SQL{277}:=“REGR_INTERCEPT”
YT_SQL{278}:=“REGR_R2”
YT_SQL{279}:=“REGR_SLOPE”
YT_SQL{280}:=“REGR_SXX”
YT_SQL{281}:=“REGR_SXY”
YT_SQL{282}:=“REGR_SYY”
YT_SQL{283}:=“RELATIVE”
YT_SQL{284}:=“RELEASE”
YT_SQL{285}:=“REPEATE”
YT_SQL{286}:=“RESIGNAL”
YT_SQL{287}:=“RESPECT”
YT_SQL{288}:=“RESTRICT”
YT_SQL{289}:=“RESULT”
YT_SQL{290}:=“RETURN”
YT_SQL{291}:=“RETURNS”
YT_SQL{292}:=“REVOKE”
YT_SQL{293}:=“RIGHT”
YT_SQL{294}:=“ROLE”
YT_SQL{295}:=“ROLLBACK”
YT_SQL{296}:=“ROLLUP”
YT_SQL{297}:=“ROUTINE”
YT_SQL{298}:=“ROW”
YT_SQL{299}:=“ROWS”
YT_SQL{300}:=“ROW_NUMBER”
YT_SQL{301}:=“SAVEPOINT”
YT_SQL{302}:=“SCHEMA”
YT_SQL{303}:=“SCOPE”
YT_SQL{304}:=“SCROLL”
YT_SQL{305}:=“SEARCH”
YT_SQL{306}:=“SECOND”
YT_SQL{307}:=“SECTION”
YT_SQL{308}:=“SELECT”
YT_SQL{309}:=“SENSITIVE”
YT_SQL{310}:=“SESSION”
YT_SQL{311}:=“SESSION_USER”
YT_SQL{312}:=“SET”
YT_SQL{313}:=“SETS”
YT_SQL{314}:=“SIGNAL”
YT_SQL{315}:=“SIMILAR”
YT_SQL{316}:=“SIZE”
YT_SQL{317}:=“SMALLINT”
YT_SQL{318}:=“SOME”
YT_SQL{319}:=“SPACE”
YT_SQL{320}:=“SPECIFIC”
YT_SQL{321}:=“SPECIFICTYPE”
YT_SQL{322}:=“SQL”
YT_SQL{323}:=“SQLCODE”
YT_SQL{324}:=“SQLERROR”
YT_SQL{325}:=“SQLEXCEPTION”
YT_SQL{326}:=“SQLSTATE”
YT_SQL{327}:=“SQLWARNING”
YT_SQL{328}:=“SQRT”
YT_SQL{329}:=“START”
YT_SQL{330}:=“STATE”
YT_SQL{331}:=“STATIC”
YT_SQL{332}:=“STDDEV_POP”
YT_SQL{333}:=“STDDEV_SAMP”
YT_SQL{334}:=“SUBMULTISET”
YT_SQL{335}:=“SUBSTRING”
YT_SQL{336}:=“SUM”
YT_SQL{337}:=“SYMMETRIC”
YT_SQL{338}:=“SYSTEM”
YT_SQL{339}:=“SYSTEM_USER”
YT_SQL{340}:=“TABLE”
YT_SQL{341}:=“TABLESAMPLE”
YT_SQL{342}:=“TEMPORARY”
YT_SQL{343}:=“THEN”
YT_SQL{344}:=“TIME”
YT_SQL{345}:=“TIMESTAMP”
YT_SQL{346}:=“TIMEZONE_HOUR”
YT_SQL{347}:=“TIMEZONE_MINUTE”
YT_SQL{348}:=“TO”
YT_SQL{349}:=“TRAILING”
YT_SQL{350}:=“TRANSACTION”
YT_SQL{351}:=“TRANSLATE”
YT_SQL{352}:=“TRANSLATION”
YT_SQL{353}:=“TREAT”
YT_SQL{354}:=“TRIGGER”
YT_SQL{355}:=“TRIM”
YT_SQL{356}:=“TRIM_ARRAY”
YT_SQL{357}:=“TRUE”
YT_SQL{358}:=“UESCAPE”
YT_SQL{359}:=“UNDER”
YT_SQL{360}:=“UNDO”
YT_SQL{361}:=“UNION”
YT_SQL{362}:=“UNIQUE”
YT_SQL{363}:=“UNKNOWN”
YT_SQL{364}:=“UNNEST”
YT_SQL{365}:=“UNTIL”
YT_SQL{366}:=“UPDATE”
YT_SQL{367}:=“UPPER”
YT_SQL{368}:=“USAGE”
YT_SQL{369}:=“USER”
YT_SQL{370}:=“USING”
YT_SQL{371}:=“VALUE”
YT_SQL{372}:=“VALUES”
YT_SQL{373}:=“VARCHAR”
YT_SQL{374}:=“VARYING”
YT_SQL{375}:=“VAR_POP”
YT_SQL{376}:=“VAR_SAMP”
YT_SQL{377}:=“VIEW”
YT_SQL{378}:=“WHEN”
YT_SQL{379}:=“WHENEVER”
YT_SQL{380}:=“WHERE”
YT_SQL{381}:=“WHILE”
YT_SQL{382}:=“WIDTH_BUCKET”
YT_SQL{383}:=“WINDOW”
YT_SQL{384}:=“WITH”
YT_SQL{385}:=“WITHIN”
YT_SQL{386}:=“WITHOUT”
YT_SQL{387}:=“WORK”
YT_SQL{388}:=“WRITE”
YT_SQL{389}:=“YEAR”
YT_SQL{390}:=“ZONE”

C_TEXTE($T_Fichier;$va_RefRacine;$va_RefBody;$va_RefTemp;$vt_Valeur_fr;$vt_Valeur_us)
C_ENTIER LONG($i;$vl_Nbgroupes;$j;$vl_NbTransUnit)

TABLEAU TEXTE(YT_4DFR;0) // Version 15.1
TABLEAU TEXTE(YT_4DUS;0)

$T_Fichier:=Fichier application+Séparateur dossier+“Contents”+Séparateur dossier+“Resources”+Séparateur dossier+“fr.lproj”+Séparateur dossier+“4D_CommandsFR.xlf”

Si (Tester chemin acces($T_Fichier)=Est un document)
$va_RefRacine:=DOM Analyser source XML($T_Fichier)

TABLEAU TEXTE($tt_RefGroup;0)
TABLEAU TEXTE($tt_RefLtransUnit;0)

$va_RefBody:=DOM Chercher élément XML($va_RefRacine;"xliff/file/body")
$vl_Nbgroupes:=XML_LireListeElémentsFils ($va_RefBody;"group";->$tt_RefGroup)

Boucle ($i;1;$vl_Nbgroupes)
	$vl_NbTransUnit:=XML_LireListeElémentsFils ($tt_RefGroup{$i};"trans-unit";->$tt_RefLtransUnit)
	Boucle ($j;1;$vl_NbTransUnit)
		$va_RefTemp:=DOM Lire élément XML($tt_RefLtransUnit{$j};"source";1;$vt_Valeur_fr)
		$va_RefTemp:=DOM Lire élément XML($tt_RefLtransUnit{$j};"target";1;$vt_Valeur_us)
		$vt_Valeur_fr:=Remplacer chaîne($vt_Valeur_fr;"@";"")
		Si ($vt_Valeur_fr#"")
			AJOUTER À TABLEAU(YT_4DFR;$vt_Valeur_fr)
		Fin de si 
		$vt_Valeur_us:=Remplacer chaîne($vt_Valeur_us;"@";"")
		Si ($vt_Valeur_us#"")
			AJOUTER À TABLEAU(YT_4DUS;$vt_Valeur_us)
		Fin de si 
	Fin de boucle 
Fin de boucle 
DOM FERMER XML($va_RefRacine)

Fin de si

TRIER TABLEAU(YT_SQL;>)
TRIER TABLEAU(YT_4DFR;>)
TRIER TABLEAU(YT_4DUS;>)

</code 4D>

<code 4D>
// Méthode : CTL_Nom_4D
// –––––––––––––––––––––––––––––––––––––––––––––––––––––
// Description :
// Edite un fichier avec l’ensemble des noms des champs et tables
//
// –––––––––––––––––––––––––––––––––––––––––––––––––––––
// Date de création et auteur :
// 13/01/2016 Pierre-Guy LECOMPTE
// –––––––––––––––––––––––––––––––––––––––––––––––––––––
// Modifications (date, auteur et but) :
//
// –––––––––––––––––––––––––––––––––––––––––––––––––––––

C_HEURE($H_RefDoc)
C_TEXTE($T_Table;$T_Champs;$T_Erreur)
C_ENTIER LONG($L_Table_Compteur;$L_Table_Total;$L_Champ_Compteur;$L_Champ_Total;$L_Erreur)

CTL_Mot_Cle

$L_Erreur:=0
$H_RefDoc:=Créer document(<>ENV_T_Dossier_Divers+“Noms des champs.txt”)

$L_Table_Total:=Lire numéro dernière table

Boucle ($L_Table_Compteur;1;$L_Table_Total)
$T_Erreur:=""
Si (Est un numéro de table valide($L_Table_Compteur))
$T_Table:=Nom de la table($L_Table_Compteur)
$L_Champ_Total:=Lire numéro dernier champ($L_Table_Compteur)
Si (Chercher dans tableau trié(YT_SQL;$T_Table;>))
$T_Erreur:="<- Mot clef SQL"
$L_Erreur:=$L_Erreur+1
Fin de si
Si (Chercher dans tableau trié(YT_4DFR;$T_Table;>))
$T_Erreur:="<- Mot clef 4DFR"
$L_Erreur:=$L_Erreur+1
Fin de si
Si (Chercher dans tableau trié(YT_4DUS;$T_Table;>))
$T_Erreur:="<- Mot clef 4DUS"
$L_Erreur:=$L_Erreur+1
Fin de si

	ENVOYER PAQUET($H_RefDoc;"\t\t\t"+$T_Table+"\t"+Chaîne($L_Champ_Total)+" champs\t"+$T_Erreur+"\r\n")
	
	Boucle ($L_Champ_Compteur;1;$L_Champ_Total)
		$T_Erreur:=""
		Si (Est un numéro de champ valide($L_Table_Compteur;$L_Champ_Compteur))
			$T_Champs:=Nom du champ($L_Table_Compteur;$L_Champ_Compteur)  // +"\t"+Chaîne(Type(Champ($L_Table_Compteur;$L_Champ_Compteur)->))
			Si (Chercher dans tableau trié(YT_SQL;$T_Champs;>))
				$T_Erreur:="<- Mot clef SQL"
				$L_Erreur:=$L_Erreur+1
			Fin de si 
			Si (Chercher dans tableau trié(YT_4DFR;$T_Champs;>))
				$T_Erreur:="<- Mot clef 4DFR"
				$L_Erreur:=$L_Erreur+1
			Fin de si 
			Si (Chercher dans tableau trié(YT_4DUS;$T_Champs;>))
				$T_Erreur:="<- Mot clef 4DUS"
				$L_Erreur:=$L_Erreur+1
			Fin de si 
			
			ENVOYER PAQUET($H_RefDoc;$T_Table+"\t"+$T_Champs+"\t"+$T_Erreur+"\r\n")
		Fin de si 
	Fin de boucle 
Fin de si 

Fin de boucle
FERMER DOCUMENT($H_RefDoc)

Si ($L_Erreur#0)
DIA_Alerte (“Il y a “+Chaîne($L_Erreur)+” erreur(s).\nLe rapport est dans le fichier :\nNoms des champs.txt.”;“Mots clés”)
Fin de si
MONTRER SUR DISQUE(Document)

TABLEAU TEXTE(YT_SQL;0)
TABLEAU TEXTE(YT_4DFR;0)
TABLEAU TEXTE(YT_4DUS;0)

</code 4D>

<code 4D>
//================================================================================
//@4ddoc-start : en
//@name : XML_LireListeElémentsFils (héritée de XML_domElementChildAllGet)
//@scope : public
//@deprecated : no
//@description : This function returns the number of all child elements (1st level)
// and fills an array of document references
//@parameter[0-OUT-count-LONGINT] : element counter
//@parameter[1-IN-domElementRef-STRING 32] : dom element ref
//@parameter[2-OUT-childElementArrayPtr-POINTER] : child element ref array pointer (optionnal, modified)
//@notes :
//@example : XML_domElementChildAllGet
//@see :
//@version : 1.00.00
//@author : Bruno LEGAY (BLE) - Copyrights A&C Consulting - 2015
//@history : CREATION : Bruno LEGAY (BLE) - 01/08/2013, 10:00:54 - v1.00.00
//@4ddoc-end
//================================================================================
// Modification : 07/07/2015 à 16:43 par Joël Laclavère

C_TEXTE($1) //domElementRef
C_TEXTE($2;$vt_Discriminant) //discriminant
C_POINTEUR($3) //child elements references array pointer
C_POINTEUR($4) //child elements name array pointer
C_ENTIER LONG($0) //number of child elements

C_ENTIER LONG($vl_count) //number of child elements
C_TEXTE($vt_domElementRef) //domElementRef
C_POINTEUR($vp_elementRefArrayPtr;$vp_elementNameArrayPtr) //child elements references array pointer
C_ENTIER LONG($vl_nbParam)
C_BOOLÉEN($vb_fillElementRefArray;$vb_fillElementNameArray)
C_TEXTE($vt_domChildElementRef;$vt_elementName) //;$vt_elementValue)

$vl_count:=0

$vl_nbParam:=Nombre de paramètres
Si ($vl_nbParam>0)
$vt_domElementRef:=$1

Au cas ou 
	: ($vl_nbParam>1)
		$vt_Discriminant:=$2
		
		Si ($vl_nbParam>2)
			Si (Type($3->)=Est un tableau chaîne) | (Type($3->)=Est un tableau texte)
				$vp_elementRefArrayPtr:=$3
			Fin de si 
			
			Si ($vl_nbParam>3)
				Si (Type($4->)=Est un tableau chaîne) | (Type($4->)=Est un tableau texte)
					$vp_elementNameArrayPtr:=$4
				Fin de si 
			Fin de si 
		Fin de si 
Fin de cas 

$vb_fillElementRefArray:=Non(Nil($vp_elementRefArrayPtr))
$vb_fillElementNameArray:=Non(Nil($vp_elementNameArrayPtr))

TABLEAU TEXTE($tt_ElementRef;0)
TABLEAU TEXTE($tt_ElementName;0)


Si (Longueur($vt_domElementRef)=16) | (Longueur($vt_domElementRef)=32) & ($vt_domElementRef#"000000000000000@")
	$vt_domChildElementRef:=DOM Lire premier élément XML enfant($vt_domElementRef;$vt_elementName)  //;$vt_elementValue)
	
	Tant que (ok=1)
		Si (Longueur($vt_domChildElementRef)>0)
			Si ($vt_Discriminant="") | (TXT_Comparer ($vt_elementName;$vt_Discriminant))  // Modifié par : Joël Laclavère (13/07/2015)
				$vl_count:=$vl_count+1
				
				Si ($vb_fillElementRefArray)
					AJOUTER À TABLEAU($tt_ElementRef;$vt_domChildElementRef)
				Fin de si 
				Si ($vb_fillElementNameArray)
					AJOUTER À TABLEAU($tt_ElementName;$vt_elementName)
				Fin de si 
			Fin de si 
		Fin de si 
		$vt_domChildElementRef:=DOM Lire élément XML frère suivant($vt_domChildElementRef;$vt_elementName)  //;$vt_elementValue)
	Fin tant que 
Fin de si 

Si ($vb_fillElementRefArray)
	  //%W-518.1
	COPIER TABLEAU($tt_ElementRef;$vp_elementRefArrayPtr->)
	  //%W+518.1
Fin de si 

Si ($vb_fillElementNameArray)
	  //%W-518.1
	COPIER TABLEAU($tt_ElementName;$vp_elementNameArrayPtr->)
	  //%W+518.1
Fin de si 

Fin de si

$0:=$vl_count

</code 4D>

<code 4D>
// TXT_Comparer
//----------------------------------------------------
//
//Exemple d’appel :
// TXT_Comparer(“abc”;“ABC”) => Faux
//----------------------------------------------------
// Création : 10/03/2015 à 18:46 par Joël Laclavère
// (01/12/2015) Pierre-Guy LECOMPTE : Ajout pour sortir plus rapidement de la boucle

C_TEXTE($1) //texte de référence
C_TEXTE($2) // texte à comprer
C_BOOLÉEN($0) //retourne vrai si strictement identique

C_ENTIER LONG($i)

//%R-
Au cas ou
: ($1#$2) //test simple
$0:=Faux

: (Longueur($1)#Longueur($2))  //test simple
	$0:=Faux
Sinon 
	$0:=Vrai
	Boucle ($i;1;Longueur($1))
		Si (Code de caractère($1[$i])#Code de caractère($2[$i]))
			$0:=Faux
			$i:=Longueur($1)
		Fin de si 
	Fin de boucle 

Fin de cas
//%R+

</code 4D>

le chemin codé est le suivant :

$CommandsXLIFFFile_T:=FILE_GetApplicationPath +Replace string($Langue_T+".lproj/4DSyntax"+$Langue_T+".xlf";"/";Folder separator)

sinon, si tu charges QST, tu auras le code + l’interface, le code du composant est ouvert.

Patrick

Ok Pierre-Guy,
en fait c’est le fichier xml qui me permet déjà de récupérer toutes les commandes du language 4D, même si toutes les commandes (concernant l’interface par exemple) ne sont pas utiles dans le code d’une page Web.

Je vais tester et les mettre au format JSON pour les intégrer en Snippets.
On peut même mettre le texte de la commande en français et l’insertion en US avec le Nr de commande.
Manquent juste les paramètres et descriptions

J’ai fait un blog post inspiré par cette demande :
https://gabrielinzirillo.wixsite.com/my4dexperience/accueil/tip-5-4d-tags-little-tricksTip 5 #4D TAGS - Petites astuces>

En fait je propose plus un workaround.

Si vous créer votre propre fichier de snippet pour un éditeur de texte je pense qu’il serait sympas de le partager ici pour que d’autres développeur puisse en profiter. A propos, quel éditeur de texte utilisez-vous? Personnellement j’aime beaucoup Sublime Text.

Bonjour Gabriel,

perso j’utilise VS Code de Microsoft (eh oui !!) qui est téléchargeable librement, assez complet et ouvert.
Avant j’utilisais Brackets, mais dans CS Code, l’explorateur de fichiers est un peu mieux à mon gout, mais tout ca c’est une question de choix perso, donc assez subjectif au final.

Donc pour VS Code, voici déjà un fichier contenant les snippets HTML :
https://forums.4d.com/4DBB_Main/x_User/323559/files/28321256.zip

C’est du format JSON avec des variables pour marquer en commentaires les débuts et fin de LOOP ou de IF par exemple.
Il suffit alors de taper “4H” dans l’éditeur pou faire apparaitre un popup avec les

Je voulais le completer avec les commandes 4D pour insérer automatiquement dans les balises 4DCODE le nom de la commande + Nr de commande, du genre :
QUERY:C277([TABLE];[TABLE]Field=$value)

J’ai récupéré le fichier XML avec les Nr et noms des commandes (dont beaucoup ne serviront pas ou peu), mais il me faudrait les paramètres des commandes pour avoir des Snippets “top”.

: Luc STELL

en fait c’est le fichier xml qui me permet déjà de récupérer toutes
les commandes du language 4D
Tu peux aussi faire une boucle pour ça :
<code 4D>
//DOA_getCommandList
C_ENTIER LONG($i_l)
C_TEXTE($cmdNom_t)
TABLEAU ENTIER LONG($cmdNum_al;0)
TABLEAU TEXTE($cmdNom_at;0)
Repeter
$i_l:=$i_l+1
$cmdNom_t:=Nom commande($i_l)
Si (OK=1) //le numéro de commande existe
Si (Longueur($cmdNom_t)>0) //la commande n’est pas désactivée
AJOUTER À TABLEAU($cmdNom_at;$cmdNom_t)
AJOUTER À TABLEAU($cmdNum_al;$i_l)
Fin de si
Fin de si
Jusque (OK=0) //fin des commandes existantes
//exemple sortie presse papier
TABLEAU TEXTE($result_a2t;2;0)
Arr_copy (->$cmdNum_al;->$result_a2t{1})
Arr_copy (->$cmdNom_at;->$result_a2t{2})
FIXER TEXTE DANS CONTENEUR(Arr2d_toCSV (->$result_a2t;"\t";"\r"))
</code 4D>
Plus simple, je trouve. La condition à la ligne 10 est à modifier, je crois, tu as des numéros de commande qui retournent “_4D” (1368) : je crois que c’est à usage interne, à ignorer quoi qu’il en soit. On pourrait (devrait ?) aussi moderniser ce code de papy, une collection au lieu des 2 tableaux synchros…

: Luc STELL

Je voulais le completer avec les commandes 4D pour insérer
automatiquement dans les balises 4DCODE le nom de la commande + Nr de
commande, du genre :
QUERY:C277([TABLE];[TABLE]Field=$value)
Quelle que soit la façon de construire, ce sera assez simple. Par contre ça ne te tokenise pas la table et le champ (*) et il faut peut-être penser aussi aux constantes, si ton code les utilise. Un autre outil pour produire du code tokenisé à usage d’un éditeur externe est… l’éditeur lui-même : j’ai posté un [url=]mini exemple ici> et il y a une https://doc.4d.com/4Dv17R3/4D/17-R3/Analyser-formule.301-3907367.fr.htmlnouvelle commande> intéressante en ce sens.

(*) On pourra me dire que me trouver à renommer tables, champs ou relations est, sans doute, la marque d’une absence de réflexion à long terme de ma part ou d’une indécision congénitale. Comme je suis un esprit retors, pervers et polémique, je répondrai que c’est cette même raison qui me pousse à tokeniser les commandes et constantes 4D, non mais sans blagues.

ta méthode marche bien, sinon mieux que le fichier xliff.
On peut récupérer également les infos sur la méthode et le theme (qui permettra d’éliminer celles qui ne servent pas) mais ca donne les commandes en français (pour les traditionalistes comme moi ayant du mal à passer aux commandes US après tant d’années à utiliser celles en FR).

Elles sont inutilisables dans une balise 4DCODE. Il faudra quand même aller piocher dans le fichier XML pour obtenir les traductions US.
Pas de trace non plus des paramètres.

Bon ca nous donnera déjà les commandes sans faute de frappe…ce qui est le plus grand nombre d’erreurs dans mes 4DCODE.
Je m’y colle ce soir…

: Luc STELL

ta méthode marche bien, sinon mieux que le fichier xliff.
C’est de Vincent, moi je ne suis que le modeste pillard. Si le “mieux” évoqué est la vitesse et la simplicité, oui : tout en mémoire et pas besoin de désosser du xml. Soit dit en passant, s’il faut vraiment parser du xml, je cherche la plupart du temps à le convertir en json, c’est nettement plus simple à coder depuis que c’est entré dans les gènes 4D.

On peut récupérer également les infos sur la méthode et le theme (qui
permettra d’éliminer celles qui ne servent pas) mais ca donne les
commandes en français (pour les traditionalistes comme moi ayant du
mal à passer aux commandes US après tant d’années à utiliser celles
en FR).
Là je ne pige pas : que t’importe, puisque le token sert justement à s’affranchir de cette contrainte ? Essaie dans une fenêtre de code fr de tapper ces textes et valide :
• “sum:C1”
-> Somme
• “[nomDeTableInexistante:1]nomDeChampInexistant:1”
-> [maTable1]monChamp1 (en supposant que tu as une table 1 qui a un champ 1, quand même…)
• “nimporteQuoi:K14:3”
-> Italique

En fait, 4D se fout complètement du texte dès lors qu’il voit le token : le token a toujours raison. Ça protège non seulement de l’exécution sur un interpréteur “de l’autre langage”, mais aussi de l’évolution des noms de commandes/constantes 4D.

Ça protège même des crises d’accentuation :mrgreen:

: Luc STELL

ta méthode marche bien, sinon mieux que le fichier xliff.

Sauf que dans le xliff, tu as les infos que tu recherches !

voici comment t’en sortir, avec une des méthodes d’Arnaud :wink:

https://forums.4d.com/Post/FR/18847378/1/18847379#18847379, pour XML_toObject

sinon, avec cela en plus, tu as tout dans un tableau d’objets :

<code 4D>
C_OBJECT($file)
$file:=New object
$language:=“en”

$path:=FILE_GetApplicationPath +Replace string($language+".lproj/4DSyntax"+$language+".xlf";"/";Folder separator)

If (Test path name($path)#Is a document)

ALERT("4DSyntax"+$language+".xlf file not found!")

Else
$xmlRef:=DOM Parse XML source($path)
$file:=XML_toObject ($xmlRef)
DOM CLOSE XML($xmlRef)

ARRAY OBJECT($commands;0)
OB GET ARRAY($file.xliff.file.body.group;"trans-unit";$commands)

End if

</code 4D>

et pour FILE_GetApplicationPath

<code 4D>
C_TEXT($0)

If (Folder separator=":") // Mac
$0:=Application file+Replace string("/Contents/Resources/";"/";Folder separator)
Else
$0:=Substring(Application file;1;Length(Application file)-6)+Replace string(“Resources/”;"/";Folder separator)
End if
</code 4D>

Pour ceux que ça intéresse, je me suis amusé à créer des snippets pour l’éditeur de texte Sublime.

Vous trouverez les explications et le lien vers le repository GitHub sur mon blog : https://gabrielinzirillo.wixsite.com/my4dexperience/blogMy 4D Experience>

(Il y a même une petite video)

( Je suis trop fort en teasing :D)

Cool, on va pouvoir écrire du code 4D en français dans des balises 4D CODE ?

j’ai pas encore testé, mais voici déjà la version pour les commandes US tel que préconisé par 4D.

C’est la version pour Code / Visual Studio de Microsoft, qui documente bien ce chapitre.
Excellent éditeur, il est gratuit.

Glisser le fichier dans le dossier “Bibliotheque/Application Support/Code/User/snippets/” (dossier Bibliotheque -ou Library- utilisateur et non Bibliotheque global)

Dans un nouveau document ouvert par Code,

  • taper “4H” pour appeler les balises <–#4Dxxx -->
  • taper “4D” pour appeler les commandes 4D à l’intérieur d’une balise <–#4DCODE -->
    si on tape “4D QU” apparaissent dans une mini fenêtre toutes les commandes 4D commençant par “QU”
    []28343627;“si on tape 4D QU apparaissent dans une mini fenêtre toutes les commandes 4D commençant par QU…”[/]

et voici le fichier à télécharger
https://forums.4d.com/4DBB_Main/x_User/323559/files/28343571.zip

si quelqu’un peut obtenir la liste des arguments pour chaque commande, je les ajouterai.

Bonjour Luc,

si tu regardes le tableau d’objet $commands dans le code que je t’ai fourni, tu as toutes les infos que tu recherches

Patrick

: Luc STELL

Cool, on va pouvoir écrire du code 4D en français dans des balises 4D
CODE ?
Ça peut même aider se détendre :
Fais moi le total ducon:C1([Employee]salary)
Vive l’égalité des salaires:C2([Employee]salary)

Il me semble même avoir vu dans un post que tu n’es pas obligé de mettre le texte de la commande à partir du moment où tu utilises le token

donc, cela pourrait donner (à vérifier) :
<code 4D>
:C1([Employee]salary)
:C2([Employee]salary)
</code 4D>

Patrick

Ca ca me plait !
La liberté totale du développeur enfin assouvie et assumée :lol:

même si ca marche, c’est un peu moins parlant comme code, et pour la maintenance je préfère la syntaxe d’Arnaud.
Ca fait des surprises quand tu relis ton code 1 an plus tard :mrgreen: