Merge pull request #60 from alefragnani/pascal

Pascal language support
pull/2748/head
Alexandru Dima 6 years ago committed by GitHub
commit 8612cdf3fc
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23

@ -26,6 +26,7 @@ Colorization and configuration supports for multiple languages for the Monaco Ed
* msdax
* mysql
* objective-c
* pascal
* pgsql
* php
* postiats

@ -41,6 +41,7 @@ bundleOne('lua/lua');
bundleOne('markdown/markdown');
bundleOne('msdax/msdax');
bundleOne('objective-c/objective-c');
bundleOne('pascal/pascal');
bundleOne('php/php');
bundleOne('powershell/powershell');
bundleOne('postiats/postiats');

@ -25,6 +25,7 @@ import './markdown/markdown.contribution';
import './msdax/msdax.contribution';
import './mysql/mysql.contribution';
import './objective-c/objective-c.contribution';
import './pascal/pascal.contribution';
import './pgsql/pgsql.contribution';
import './php/php.contribution';
import './postiats/postiats.contribution';

@ -0,0 +1,15 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import { registerLanguage } from '../_.contribution';
registerLanguage({
id: 'pascal',
extensions: ['.pas', '.p', '.pp'],
aliases: ['Pascal', 'pas'],
mimetypes: ['text/x-pascal-source', 'text/x-pascal'],
loader: () => import('./pascal')
});

@ -0,0 +1,147 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import { testTokenization } from '../test/testRunner';
testTokenization('pascal', [
// Comments - single line
[{
line: '//',
tokens: [
{ startIndex: 0, type: 'comment.pascal' }
]
}],
[{
line: ' // a comment',
tokens: [
{ startIndex: 0, type: 'white.pascal' },
{ startIndex: 4, type: 'comment.pascal' }
]
}],
[{
line: '// a comment',
tokens: [
{ startIndex: 0, type: 'comment.pascal' }
]
}],
[{
line: '//sticky comment',
tokens: [
{ startIndex: 0, type: 'comment.pascal' }
]
}],
// Comments - multi line (single line)
[{
line: '{}',
tokens: [
{ startIndex: 0, type: 'comment.pascal' }
]
}],
[{
line: ' { a comment }',
tokens: [
{ startIndex: 0, type: 'white.pascal' },
{ startIndex: 4, type: 'comment.pascal' }
]
}],
[{
line: '{ a comment }',
tokens: [
{ startIndex: 0, type: 'comment.pascal' }
]
}],
[{
line: '{sticky comment}',
tokens: [
{ startIndex: 0, type: 'comment.pascal' }
]
}],
// Comments - multi line (multi line)
[{
line: '{ start of multiline comment ',
tokens: [
{ startIndex: 0, type: 'comment.pascal' }
]
}, {
line: 'a comment between curly',
tokens: [
{ startIndex: 0, type: 'comment.pascal'}
]
}, {
line: 'end of multiline comment}',
tokens: [
{ startIndex: 0, type: 'comment.pascal'}
]
}],
// Keywords
[{
line: 'program Test; begin writeln(\'hello\'); end.',
tokens: [
{ startIndex: 0, type: 'keyword.program.pascal'},
{ startIndex: 7, type: 'white.pascal'},
{ startIndex: 8, type: 'identifier.pascal'},
{ startIndex: 12, type: 'delimiter.pascal'},
{ startIndex: 13, type: 'white.pascal'},
{ startIndex: 14, type: 'keyword.begin.pascal'},
{ startIndex: 19, type: 'white.pascal'},
{ startIndex: 20, type: 'identifier.pascal'},
{ startIndex: 27, type: 'delimiter.parenthesis.pascal'},
{ startIndex: 28, type: 'string.pascal'},
{ startIndex: 34, type: 'string.quote.pascal'},
{ startIndex: 35, type: 'delimiter.parenthesis.pascal'},
{ startIndex: 36, type: 'delimiter.pascal'},
{ startIndex: 37, type: 'white.pascal'},
{ startIndex: 38, type: 'keyword.end.pascal'},
{ startIndex: 41, type: 'delimiter.pascal'},
]
}],
// Numbers
[{
line: '0',
tokens: [
{ startIndex: 0, type: 'number.pascal'}
]
}],
[{
line: '0;',
tokens: [
{ startIndex: 0, type: 'number.pascal'},
{ startIndex: 1, type: 'delimiter.pascal'}
]
}],
[{
line: '2.4',
tokens: [
{ startIndex: 0, type: 'number.float.pascal'}
]
}],
[{
line: '2.4;',
tokens: [
{ startIndex: 0, type: 'number.float.pascal'},
{ startIndex: 3, type: 'delimiter.pascal'}
]
}],
[{
line: '$123FF',
tokens: [
{ startIndex: 0, type: 'number.hex.pascal'}
]
}]
]);

@ -0,0 +1,152 @@
/*---------------------------------------------------------------------------------------------
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the MIT License. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import IRichLanguageConfiguration = monaco.languages.LanguageConfiguration;
import ILanguage = monaco.languages.IMonarchLanguage;
export const conf: IRichLanguageConfiguration = {
// the default separators except `@$`
wordPattern: /(-?\d*\.\d\w*)|([^\`\~\!\#\%\^\&\*\(\)\-\=\+\[\{\]\}\\\|\;\:\'\"\,\.\<\>\/\?\s]+)/g,
comments: {
lineComment: '//',
blockComment: ['{', '}'],
},
brackets: [
['{', '}'],
['[', ']'],
['(', ')'],
['<', '>'],
],
autoClosingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '<', close: '>' },
{ open: '\'', close: '\'' },
],
surroundingPairs: [
{ open: '{', close: '}' },
{ open: '[', close: ']' },
{ open: '(', close: ')' },
{ open: '<', close: '>' },
{ open: '\'', close: '\'' },
],
folding: {
markers: {
start: new RegExp("^\\s*\\{\\$REGION(\\s\\'.*\\')?\\}"),
end: new RegExp("^\\s*\\{\\$ENDREGION\\}")
}
}
};
export const language = <ILanguage>{
defaultToken: '',
tokenPostfix: '.pascal',
ignoreCase: true,
brackets: [
{ open: '{', close: '}', token: 'delimiter.curly' },
{ open: '[', close: ']', token: 'delimiter.square' },
{ open: '(', close: ')', token: 'delimiter.parenthesis' },
{ open: '<', close: '>', token: 'delimiter.angle' }
],
keywords: [
'absolute', 'abstract', 'all', 'and_then', 'array', 'as', 'asm',
'attribute', 'begin', 'bindable', 'case', 'class', 'const',
'contains', 'default', 'div', 'else', 'end', 'except',
'exports', 'external', 'far', 'file', 'finalization', 'finally',
'forward', 'generic', 'goto', 'if', 'implements', 'import', 'in',
'index', 'inherited', 'initialization', 'interrupt', 'is', 'label',
'library', 'mod', 'module', 'name', 'near', 'not', 'object', 'of',
'on', 'only', 'operator', 'or_else', 'otherwise', 'override',
'package', 'packed', 'pow', 'private', 'program', 'protected',
'public', 'published', 'interface', 'implementation', 'qualified',
'read', 'record', 'resident', 'requires', 'resourcestring',
'restricted', 'segment', 'set', 'shl', 'shr', 'specialize', 'stored',
'then', 'threadvar', 'to', 'try', 'type', 'unit', 'uses', 'var',
'view', 'virtual', 'dynamic', 'overload', 'reintroduce', 'with',
'write', 'xor', 'true', 'false', 'procedure', 'function',
'constructor','destructor','property', 'break', 'continue', 'exit',
'abort', 'while', 'do', 'for', 'raise', 'repeat','until'
],
typeKeywords: [
'boolean', 'double', 'byte', 'integer', 'shortint', 'char',
'longint', 'float', 'string'
],
operators: [
'=', '>', '<', '<=', '>=', '<>', ':', ':=', 'and', 'or',
'+', '-', '*', '/', '@', '&', '^', '%'
],
// we include these common regular expressions
symbols: /[=><:@\^&|+\-*\/\^%]+/,
// The main tokenizer for our languages
tokenizer: {
root: [
// identifiers and keywords
[/[a-zA-Z_][\w]*/, {
cases: {
'@keywords': { token: 'keyword.$0' },
'@default': 'identifier'
}
}],
// whitespace
{ include: '@whitespace' },
// delimiters and operators
[/[{}()\[\]]/, '@brackets'],
[/[<>](?!@symbols)/, '@brackets'],
[/@symbols/, {
cases: {
'@operators': 'delimiter',
'@default': ''
}
}],
// numbers
[/\d*\.\d+([eE][\-+]?\d+)?/, 'number.float'],
[/\$[0-9a-fA-F]{1,16}/, 'number.hex'],
[/\d+/, 'number'],
// delimiter: after number because of .\d floats
[/[;,.]/, 'delimiter'],
// strings
[/'([^'\\]|\\.)*$/, 'string.invalid'], // non-teminated string
[/'/, 'string', '@string'],
// characters
[/'[^\\']'/, 'string'],
[/'/, 'string.invalid'],
[/\#\d+/,'string']
],
comment: [
[/[^\*\}]+/, 'comment' ],
//[/\(\*/, 'comment', '@push' ], // nested comment not allowed :-(
[/\}/, 'comment', '@pop' ],
[/[\{]/, 'comment' ]
],
string: [
[/[^\\']+/, 'string'],
[/\\./, 'string.escape.invalid'],
[/'/, { token: 'string.quote', bracket: '@close', next: '@pop' } ]
],
whitespace: [
[/[ \t\r\n]+/, 'white'],
[/\{/, 'comment', '@comment' ],
[/\/\/.*$/, 'comment'],
],
},
};

@ -49,6 +49,7 @@ define(['require'], function () {
'release/dev/msdax/msdax.test',
'release/dev/mysql/mysql.test',
'release/dev/objective-c/objective-c.test',
'release/dev/pascal/pascal.test',
'release/dev/perl/perl.test',
'release/dev/pgsql/pgsql.test',
'release/dev/php/php.test',

Loading…
Cancel
Save